Exception Fact Sheet for "Scarab"

The goal of an Exception Fact Sheet is to reveal the design of exception handling in an application.

--Maxence, Martin

For feedback, please contact Martin

Table of contents

Basic Statistics

Number of Classes 411
Number of Domain Exception Types (Thrown or Caught) 7
Number of Domain Checked Exception Types 1
Number of Domain Runtime Exception Types 1
Number of Domain Unknown Exception Types 5
nTh = Number of Throw 325
nTh = Number of Throw in Catch 136
Number of Catch-Rethrow (may not be correct) 16
nC = Number of Catch 498
nCTh = Number of Catch with Throw 135
Number of Empty Catch (really Empty) 11
Number of Empty Catch (with comments) 31
Number of Empty Catch 42
nM = Number of Methods 3197
nbFunctionWithCatch = Number of Methods with Catch 385 / 3197
nbFunctionWithThrow = Number of Methods with Throw 242 / 3197
nbFunctionWithThrowS = Number of Methods with ThrowS 1561 / 3197
nbFunctionTransmitting = Number of Methods with "Throws" but NO catch, NO throw (only transmitting) 1297 / 3197
P1 = nCTh / nC 27.1% (0.271)
P2 = nMC / nM 12% (0.12)
P3 = nbFunctionWithThrow / nbFunction 7.6% (0.076)
P4 = nbFunctionTransmitting / nbFunction 40.6% (0.406)
P5 = nbThrowInCatch / nbThrow 41.8% (0.418)
R2 = nCatch / nThrow 1.532
A1 = Number of Caught Exception Types From External Libraries 43
A2 = Number of Reused Exception Types From External Libraries (thrown from application code) 26

W1 is a rough estimation of the richness of the exception model. It does not take into account the inheritance relationships between domain exceptions.

Proportion P1 measures the overall exception flow. According to our experience, it varies from 5% to 70%. Early-catch design generally yields a low P1, libraries that must warn clients about errors (e.g. databases) generally have a high P1.

Proportion P2 measures the dispersion of catch blocks in the application. According to our experience, it varies from 2% to 15%. A small P2 indicates a rather centralized management of errors.

R1 shows how many exceptions types from libraries (incl. JDK) are thrown from application code. For instance, IllegalArgumentException comes from the JDK but is used in many applications.

A1 measures the awareness of the application to library exceptions. A high value of A1 means either that the application is polluted with checked exceptions or that it is able to apply specific recovery depending on the library exception.

Exception Hierachy

Exception Map

Each exception that is used at least once in the project is a dot. A orange dot represents a domain exception that is defined in the application. A blue dot exception is defined in the JDK or in a library. The x-axis represents the number of times an exception is caught, the y-axis the number of times an exception is thrown.

Exceptions With State

State means fields. Number of exceptions with state: 4
ScarabLocalizedTorqueException 
              package org.tigris.scarab.util;public class ScarabLocalizedTorqueException extends TorqueException implements Localizable
{
    private final Throwable throwable;

    // may be null
    private ScarabLocalizationTool localizer;
    
    /**
     * Constructs a TorqueException wrapper for a given throwable.
     * The wrapper is simply a container with no special
     * functionality.
     * @param e
     */
    public ScarabLocalizedTorqueException(final Throwable t)
    {
        throwable = t;
        localizer = null;
    }

    /**
     * Set the localizer to be used in later calls to {@link #getLocalizedMessage()}
     * @param theLocalizer the localizer (may be <code>null</code>)
     */
     public void setLocalizer(final ScarabLocalizationTool theLocalizer)
     {
        localizer = theLocalizer;
     }
    
    /**
     * Delegator for the wrapped exceptions getMessage() method.
     * @return the wrapped exception's message
     */
    public String getMessage()
    {
        return throwable.getMessage();
    }


    /**
     * Localize this exception using the wrapped throwable.
     * return the localized message, else return the message string
     * of the wrapped throwable.
     * @param l10n
     * @return
     */
    public String getMessage(final ScarabLocalizationTool l10n)
    {
        return l10n.getMessage(throwable);
    }    

    /**
     * Return the localized message for that throwable, if a localizer
     * was defined using {@link #setLocalizer(ScarabLocalizationTool)}
     * @return the localized message.
     */
    public String getLocalizedMessage()
    {   
        if (localizer != null)
        {
            return getMessage(localizer);
        } 
        else
        {
            return super.getLocalizedMessage();
        }
    }
}
ScarabException 
              package org.tigris.scarab.util;public class ScarabException extends TurbineException //implements Localizable
{
    /**
     * The exception message in non-localized form.
     * Further infos, see the {@link #getMessage(L10N) getmessage } methods below.
     */
    private Localizable l10nMessage;
    

    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * resource and no parameters.
     * @param theKey the l10n error key.
     */
    public ScarabException(LocalizationKey theKey)
    {
         l10nMessage = new L10NMessage(theKey);
    }

    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * resource and a nested Throwable.
     * @param theKey the l10n error key.
     * @param nested
     */
    public ScarabException(LocalizationKey theKey, Throwable nested)
    {
        super(nested);
        l10nMessage = new L10NMessage(theKey, nested);
    }


    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * Localizable .
     * @param theL10nInstance the l10n error key.
     */
    public ScarabException(Localizable theL10nInstance)
    {
         l10nMessage = theL10nInstance;
    }
 
    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * Localizable and a nested Throwable.
     * @param theL10nInstance the l10n error key.
     * @param nested
     */
    public ScarabException(Localizable theL10nInstance, Throwable nested)
    {
        super(nested);
        l10nMessage = theL10nInstance;
    }

    
    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * resource and a list of parameters.
     * @param theL10nInstance the l10n error key.
     * @param theParams
     */
    public ScarabException (LocalizationKey theKey, Object[] theParams)
    {
        l10nMessage = new L10NMessage(theKey, theParams);
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and one parameter.
     * @param theL10nInstance the l10n error key.
     * @param p1
     */
    public ScarabException (LocalizationKey theKey, Object p1)
    {
        this(theKey, new Object[] {p1});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and two parameters.
     * @param theL10nInstance the l10n error key.
     * @param p1
     * @param p2
     */
    public ScarabException (LocalizationKey theKey, Object p1, Object p2)
    {
        this(theKey, new Object[] {p1, p2});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and three parameters.
     * @param theL10nInstance the l10n error key.
     * @param p1
     * @param p2
     * @param p3
     */
    public ScarabException (LocalizationKey theKey, Object p1, Object p2, Object p3)
    {
        this(theKey, new Object[] {p1, p2, p3});
    }
  

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and an aritrary set of parameters.
     * 
     * @param theKey
     * @param nested
     * @param theParams
     */
    public ScarabException (LocalizationKey theKey, Throwable nested, Object[] theParams)
    {
        this(new L10NMessage(theKey, theParams),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and one parameter.
     * @param theKey
     * @param nested
     * @param p1
     */
    public ScarabException (LocalizationKey theKey, Throwable nested, Object p1)
    {
        this(new L10NMessage(theKey, p1),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and two parameters.
     * @param theKey
     * @param nested
     * @param p1
     * @param p2
     */
    public ScarabException (LocalizationKey theKey, Throwable nested, Object p1, Object p2)
    {
        this(new L10NMessage(theKey, p1, p2),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and three parameters.
     * @param theKey
     * @param nested
     * @param p1
     * @param p2
     * @param p3
     */
    public ScarabException (LocalizationKey theKey, Throwable nested, Object p1, Object p2, Object p3)
    {
        this(new L10NMessage(theKey, p1, p2, p3),nested);
    }

    /**
     * return the L10NInstance, or null, if no L10N key was given.
     * @return
     */
    public Localizable getL10nMessage()
    {
        return l10nMessage;
    }
    
    /** 
     * return the localized message by use of the
     * given ScarabLocalizationTool. For further infos see
     * {@link #getMessage() getMessage }
     *
     * @deprecated Does not follow core java patterns. Use setLocalizer(..) then getLocalizedMessage() instead.
     *
     * @param l10n
     * @return
     */
    public String getMessage(final ScarabLocalizationTool l10n)
    {
        return (l10nMessage==null)
            ? super.getMessage()
            : l10nMessage.getMessage(l10n);
    }
 
    /**
     * return the localized message in english.
     * Note: It is preferrable to use 
     * {@link #getMessage(ScarabLocalizationTool) getMessage }
     * Currently it is possible, that a ScarabException
     * contains NO L10NInstance. This is due to the deprecated
     * constructors {@link #ScarabException() ScarabException }
     * and {@link #ScarabException(String) ScarabException }
     * Eventually (after these constructors have been deleted
     * from the code base) we guarantee, that ScarabException 
     * is fully localized.
     *
     * @return localized english text
     */
    public String getMessage()
    {
        return (l10nMessage==null)
            ? super.getMessage()
            : l10nMessage.getMessage();
    }

    /**
     * Holds value of property localizer.
     */
    private ScarabLocalizationTool localizer;

    /**
     * Setter for property l10n.
     * @param l10n New value of property l10n.
     */
    public void setLocalizer(final ScarabLocalizationTool localizer)
    {

        this.localizer = localizer;
    }

    public String getLocalizedMessage()
    {
        return (l10nMessage==null)
            ? super.getMessage()
            : (localizer == null)
                ? l10nMessage.getMessage()
                : l10nMessage.getMessage(localizer);
    }
}
ScarabRuntimeException 
              package org.tigris.scarab.util;public class ScarabRuntimeException extends RuntimeException //implements Localizable
{
    /**
     * The exception message in non-localized form.
     * Further infos, see the {@link #getMessage(L10N) getmessage } methods below.
     */
    Localizable l10nMessage;
    
    /**
     * Placeholder for a nested exception (may be null)
     */
    Throwable nested;

    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * resource and no parameters.
     * @param theKey the l10n error key.
     */
    public ScarabRuntimeException(LocalizationKey theKey)
    {
         l10nMessage = new L10NMessage(theKey);
         nested      = null;
    }

    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * resource and a nested Throwable.
     * @param theKey the l10n error key.
     * @param aNested
     */
    public ScarabRuntimeException(LocalizationKey theKey, Throwable aNested)
    {
        super();
        l10nMessage = new L10NMessage(theKey, nested);
        nested      = aNested;
    }


    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * Localizable .
     * @param theL10nInstance the l10n error key.
     */
    public ScarabRuntimeException(Localizable theL10nInstance)
    {
         l10nMessage = theL10nInstance;
         nested      = null;
    }
 
    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * Localizable and a nested Throwable.
     * @param theL10nInstance the l10n error key.
     * @param aNested
     */
    public ScarabRuntimeException(Localizable theL10nInstance, Throwable aNested)
    {
        super();
        l10nMessage = theL10nInstance;
        nested      = aNested;
    }

    
    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * resource and a list of parameters.
     * @param theL10nInstance the l10n error key.
     * @param theParams
     */
    public ScarabRuntimeException (LocalizationKey theKey, Object[] theParams)
    {
        l10nMessage = new L10NMessage(theKey, theParams);
        nested      = null;
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource and one parameter.
     * @param theL10nInstance the l10n error key.
     * @param p1
     */
    public ScarabRuntimeException (LocalizationKey theKey, Object p1)
    {
        this(theKey, new Object[] {p1});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource and two parameters.
     * @param theL10nInstance the l10n error key.
     * @param p1
     * @param p2
     */
    public ScarabRuntimeException (LocalizationKey theKey, Object p1, Object p2)
    {
        this(theKey, new Object[] {p1, p2});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource and three parameters.
     * @param theL10nInstance the l10n error key.
     * @param p1
     * @param p2
     * @param p3
     */
    public ScarabRuntimeException (LocalizationKey theKey, Object p1, Object p2, Object p3)
    {
        this(theKey, new Object[] {p1, p2, p3});
    }
  

    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource, nested Throwable and an aritrary set of parameters.
     * 
     * @param theKey
     * @param nested
     * @param theParams
     */
    public ScarabRuntimeException (LocalizationKey theKey, Throwable nested, Object[] theParams)
    {
        this(new L10NMessage(theKey, theParams),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource, nested Throwable and one parameter.
     * @param theKey
     * @param nested
     * @param p1
     */
    public ScarabRuntimeException (LocalizationKey theKey, Throwable nested, Object p1)
    {
        this(new L10NMessage(theKey, p1),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource, nested Throwable and two parameters.
     * @param theKey
     * @param nested
     * @param p1
     * @param p2
     */
    public ScarabRuntimeException (LocalizationKey theKey, Throwable nested, Object p1, Object p2)
    {
        this(new L10NMessage(theKey, p1, p2),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource, nested Throwable and three parameters.
     * @param theKey
     * @param nested
     * @param p1
     * @param p2
     * @param p3
     */
    public ScarabRuntimeException (LocalizationKey theKey, Throwable nested, Object p1, Object p2, Object p3)
    {
        this(new L10NMessage(theKey, p1, p2, p3),nested);
    }

    /**
     * return the L10NInstance, or null, if no L10N key was given.
     * @return
     */
    public Localizable getL10nMessage()
    {
        return l10nMessage;
    }
    
    /** 
     * return the localized message by use of the
     * given ScarabLocalizationTool. For further infos see
     * {@link #getMessage() getMessage }
     *
     * @deprecated Does not follow core java patterns. Use setLocalizer(..) then getLocalizedMessage() instead.     
     *
     * @param l10n
     * @return
     */
    public String getMessage(ScarabLocalizationTool l10n)
    {
        String result;
        if (l10nMessage == null)
        {
            if (nested == null)
            {
                result = super.getMessage();
            }
            else
            {
                if (  nested instanceof ScarabRuntimeException )
                {
                    result = ((ScarabRuntimeException)nested).getMessage(l10n);
                }
                else if (  nested instanceof ScarabException )
                {
                    result = ((ScarabException)nested).getMessage(l10n);
                }
                else
                {
                    result = nested.getMessage();
                }
            }
        }
        else
        {
            result = l10nMessage.getMessage(l10n);
        }
        return result;
    }
 
    /**
     * return the localized message in english.
     * Note: It is preferrable to use 
     * {@link #getMessage(ScarabLocalizationTool) getMessage }
     *
     * @return localized english text
     */
    public String getMessage()
    {
        String result;
        if (l10nMessage == null)
        {
            if (nested == null)
            {
                result = super.getMessage();
            }
            else
            {
                result = nested.getMessage();
            }
        }
        else
        {
            result = l10nMessage.getMessage();
        }
        return result;
    }

}
ScarabLocalizedTurbineSecurityException 
              package org.tigris.scarab.util;public class ScarabLocalizedTurbineSecurityException extends TurbineSecurityException implements Localizable
{
    private final Throwable throwable;

    // may be null
    private ScarabLocalizationTool localizer;
    
    
    /**
     * Constructs a TurbineSecurityException wrapper for a given exception.
     * The wrapper is simply a container with no special
     * functionality.
     * @param e
     */
    public ScarabLocalizedTurbineSecurityException(final Throwable t)
    {
        super("");
        throwable = t;
        localizer = null;
    }
    
    /**
     * Set the localizer to be used in later calls to {@link #getLocalizedMessage()}
     * @param theLocalizer the localizer (may be <code>null</code>)
     */
     public void setLocalizer(final ScarabLocalizationTool theLocalizer)
     {
        localizer = theLocalizer;
     }
    
    /**
     * Delegator for the wrapped exceptions getMessage() method.
     * @return the wrapped exception's message
     */
    public String getMessage()
    {
        return throwable.getMessage();
    }


    /**
     * Localize this exception using the wrapped exception.
     * return the localized message, else return the message string
     * of the wrapped exception.
     * @param l10n
     * @return
     */
    public String getMessage(final ScarabLocalizationTool l10n)
    {
        return l10n.getMessage(throwable);
    }    
    
    /**
     * Return the localized message for that throwable, if a localizer
     * was defined using {@link #setLocalizer(ScarabLocalizationTool)}
     * @return the localized message.
     */
    public String getLocalizedMessage()
    {   
        if (localizer != null)
        {
            return getMessage(localizer);
        } 
        else
        {
            return super.getLocalizedMessage();
        }
    }

}

Thrown Exceptions Summary

A (Domain) exception is defined in the application. A (Lib) exception is defined in the JDK or in a library. An exception can be thrown, thrown from within a catch, or declared in the signature of a method (usually for checked exceptions). Hovering over a number triggers showing code snippets from the application code.

Type Exception Thrown Thrown
from Catch 		Declared
- Unknown 20 
              
//in java/org/tigris/scarab/tools/ScarabRequestTool.java
throw e;

              
//in java/org/tigris/scarab/tools/ScarabRequestTool.java
throw e;

              
//in java/org/tigris/scarab/search/CachedQuery.java
throw e;

              
//in java/org/tigris/scarab/om/ActivityManager.java
throw (TorqueException)e;

              
//in java/org/tigris/scarab/om/AbstractScarabModule.java
throw ve;

              
//in java/org/tigris/scarab/om/AbstractScarabModule.java
throw ve;

              
//in java/org/tigris/scarab/om/AbstractScarabModule.java
throw ve;

              
//in java/org/tigris/scarab/om/AttributeGroup.java
throw e;

              
//in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
throw e;

              
//in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
throw e;

              
//in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
throw e;

              
//in java/org/tigris/scarab/actions/ModifyModule.java
throw e;

              
//in java/org/tigris/scarab/actions/admin/Approval.java
throw e;

              
//in java/org/tigris/scarab/actions/setup/AntRunner.java
throw exc;

              
//in java/org/tigris/scarab/actions/setup/AntRunner.java
throw err;

              
//in java/org/tigris/scarab/util/xmlissues/BaseDate.java
throw e;

              
//in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
throw e;

              
//in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
throw e;

              
//in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
throw e;

              
//in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
throw e;
- -
- Builder 0 - -
- Variable 20 
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
throw e;

              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
throw e;

              
// in java/org/tigris/scarab/search/CachedQuery.java
throw e;

              
// in java/org/tigris/scarab/om/ActivityManager.java
throw (TorqueException)e;

              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
throw ve;

              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
throw ve;

              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
throw ve;

              
// in java/org/tigris/scarab/om/AttributeGroup.java
throw e;

              
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
throw e;

              
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
throw e;

              
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
throw e;

              
// in java/org/tigris/scarab/actions/ModifyModule.java
throw e;

              
// in java/org/tigris/scarab/actions/admin/Approval.java
throw e;

              
// in java/org/tigris/scarab/actions/setup/AntRunner.java
throw exc;

              
// in java/org/tigris/scarab/actions/setup/AntRunner.java
throw err;

              
// in java/org/tigris/scarab/util/xmlissues/BaseDate.java
throw e;

              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
throw e;

              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
throw e;

              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
throw e;

              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
throw e;
- -
(Domain) ScarabException 83 
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Object getSessionAttribute(String key) throws ScarabException
    {
        HttpSession session = data.getSession();
        Object value;
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        value = session.getAttribute(key);
        return value;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean hasSessionAttribute(String key) throws ScarabException
    {
        HttpSession session = data.getSession();
        Object value;
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        value = session.getAttribute(key);
        return value != null;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean setSessionAttribute(String key, Object value) throws ScarabException
    {
        HttpSession session = data.getSession();
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        session.setAttribute(key,value);
        return true;
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setChainedValue(final AttributeValue  v)
        throws TorqueException, ScarabException
    {
        if (v == null)
        {
            this.chainedValue = null;
        }
        else 
        {        
            if (v.getAttributeId() == null && getAttributeId() != null) 
            {
                v.setAttributeId(getAttributeId());
            }
            else if (v.getAttribute() != null 
                     && !v.getAttribute().equals(getAttribute()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainAttributeValues,
                                          v.getAttributeId(),
                                          getAttributeId());
            }
            
            if (v.getIssueId() == null && getIssueId() != null) 
            {
                v.setIssueId(getIssueId());
            }
            else if (v.getIssue() != null 
                      && !v.getIssue().equals(getIssue()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainIssues,
                                          v.getIssueId(),
                                          getIssueId());
            }

            if (this.chainedValue == null) 
            {
                this.chainedValue = v;
            }
            else 
            {
                chainedValue.setChainedValue(v);
            }
            
            if (activitySet != null) 
            {
                v.startActivitySet(activitySet);
            }        
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void startActivitySet(ActivitySet activitySet)
        throws ScarabException, TorqueException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionCanNotStartActivitySet);
        }
        
        if (this.activitySet == null) 
        {
            this.activitySet = activitySet;
        }
        else
        {
            throw new ScarabException(L10NKeySet.ExceptionActivitySetInProgress);
        }
/*
This is wrong. It prevented the old/new value stuff from working properly!
If we have an existing issue and we change some attributes, then when the
history was created, the data was not valid in it for some reason. I'm not
quite sure why this was added. (JSS)

Leaving here so that John can remove or fix.

        oldOptionIdIsSet = false;
        oldValueIsSet = false;
        oldOptionId = null;
        oldValue = null;
*/

        // Check for previous active activities on this attribute 
        // If they exist, set old value for this activity
        List result = null;
        final Issue issue = getIssue();
        if (issue != null)
        {
            result = issue
                .getActivitiesWithNullEndDate(getAttribute());
        }
        if (result != null && result.size() > 0)
        {
            for (int i=0; i<result.size(); i++)
            {
                final Activity a = (Activity)result.get(i);
                oldOptionId = a.getNewOptionId();
                oldValue = a.getNewValue();
            }
        }
        if (chainedValue != null) 
        {
            chainedValue.startActivitySet(activitySet);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
private void checkActivitySet(LocalizationKey l10nKey)
        throws ScarabException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(l10nKey);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public Integer[] getUserIds()
        throws ScarabException
    {
        throw new ScarabException(L10NKeySet.ExceptionGetUserIdsNotImplemented);
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public RModuleAttribute getRModuleAttribute()
        throws TorqueException, ScarabException
    {
        final Issue issue = getIssue();
        RModuleAttribute rma = null;
        if (issue != null)
        {
            final Module module = issue.getModule();
            if (module != null)
            {
                rma = module.getRModuleAttribute(
                    getAttribute(), getIssue().getIssueType());
            }
            else
            {
                throw new ScarabException (L10NKeySet.ExceptionGeneral,
                        "Module is null: Please report this issue."); //EXCEPTION
            }
        }
        else
        {
            throw new ScarabException (L10NKeySet.ExceptionGeneral,
                    "Issue is null: Please report this issue."); //EXCEPTION
        }
        return rma;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonLeafRModuleOptions(final Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getLeafRModuleOptions(
                attribute,
                item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleOptionTree(Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getOptionTree(attribute, item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }  
        catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
    }
              
// in java/org/tigris/scarab/om/Query.java
public boolean saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped query, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        Exception exception=null; // temporary store a thrown exception

        if (getScopeId().equals(Scope.PERSONAL__PK) 
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        }
        else
        {
            setApproved(false);

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");

                final ScarabUser[] toUsers = module
                    .getUsers(ScarabSecurity.ITEM__APPROVE);

                if (Log.get().isDebugEnabled()) 
                {
                    if (toUsers == null || toUsers.length ==0) 
                    {
                        Log.get().debug("No users to approve query.");    
                    }
                    else 
                    {
                        Log.get().debug("Users to approve query: ");    
                        for (int i=0; i<toUsers.length; i++) 
                        {
                            Log.get().debug(toUsers[i].getEmail());
                        }  
                    }          
                }
                
                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewQueryRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx,
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null,
                        template);
                }
                catch (Exception e)
                {
                    exception = e;
                }
            }
        }
        if (getMITList() != null) 
        {
            getMITList().save();
            // it would be good if this updated our list id, but it doesn't
            // happen automatically so reset it.
            setMITList(getMITList());            
        }
        save();
        if(exception != null)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral, exception);
        }
        return true;
    }
              
// in java/org/tigris/scarab/om/Query.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/Query.java
public void delete(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module)
          || (user.getUserId().equals(getUserId()) 
             && getScopeId().equals(Scope.PERSONAL__PK)))
        {
            // Delete user-query maps.
            final List rqus = getRQueryUsers();
            for (int i=0; i<rqus.size(); i++)
            {
                final RQueryUser rqu = (RQueryUser)rqus.get(i);
                rqu.delete(user);
            }
            setDeleted(true);
            save();
            
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
                                          final ScarabUser user, 
                                          final Attachment attachment)
        throws TorqueException,ScarabException
    {
        if (attachment != null && attachment.getAttachmentId() == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNeedToSaveAttachement);
        }
        final ActivitySet activitySet = new ActivitySet();
        activitySet.setTypeId(typeId);
        activitySet.setCreatedBy(user.getUserId());
        activitySet.setCreatedDate(new Date());
        if (attachment != null && 
            attachment.getData() != null &&
            attachment.getData().length() > 0)
        {
            activitySet.setAttachment(attachment);
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
protected void delete(final boolean overrideLock)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        final IssueType issueType = IssueTypeManager
           .getInstance(getIssueTypeId(), false);
        if (issueType.getLocked() && !overrideLock)
        { 
            throw new ScarabException(L10NKeySet.CannotDeleteAttributeFromLockedIssueType);
        }            
        else
        {
            final Criteria c = new Criteria()
                .add(RModuleAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleAttributePeer.doDelete(c);
            final Attribute attr = getAttribute();
            String attributeType = null;
            attributeType = (attr.isUserAttribute() ? Module.USER : Module.NON_USER);
            module.getRModuleAttributes(getIssueType(), false, attributeType)
                                        .remove(this);
            WorkflowFactory.getInstance().deleteWorkflowsForAttribute(
                                          attr, module, getIssueType());

            // delete module-user-attribute mappings
            final Criteria crit = new Criteria()
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attr.getAttributeId())
                .add(RModuleUserAttributePeer.MODULE_ID, 
                     getModuleId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                     getIssueTypeId());
            RModuleUserAttributePeer.doDelete(crit);

            // delete module-option mappings
            if (attr.isOptionAttribute())
            {
                final List optionList = module.getRModuleOptions(attr, 
                                  IssueTypePeer.retrieveByPK(getIssueTypeId()), 
                                  false);
                if (optionList != null && !optionList.isEmpty())
                {
                    final List optionIdList =
                        new ArrayList(optionList.size());
                    for (int i = 0; i < optionList.size(); i++)
                    { 
                        optionIdList.add(((RModuleOption)
                                          optionList.get(i))
                                         .getOptionId());
                    }
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID, getModuleId())
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,
                             getIssueTypeId())
                        .addIn(RModuleOptionPeer.OPTION_ID, optionIdList);
                    RModuleOptionPeer.doDelete(c2);
                }
            }
        }

        RModuleAttributeManager.removeInstanceFromCache(this);
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public void delete()
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

            final IssueType issueType = IssueTypeManager
               .getInstance(getIssueTypeId(), false);
            if (issueType.getLocked())
            { 
                throw new ScarabException(L10NKeySet.ExceptionDeleteOptionFromLockedIssueType);
            }            
            else
            {
                Integer moduleId    = getModuleId();
                Integer issueTypeId = getIssueTypeId();
                Integer optionId    = getOptionId();
                int orderNumber     = getOrder();

                // delete the option
                final Criteria c = new Criteria()
                    .add(RModuleOptionPeer.MODULE_ID, moduleId)
                    .add(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId)
                    .add(RModuleOptionPeer.OPTION_ID, optionId);
                RModuleOptionPeer.doDelete(c);
                
                // delete associated workflow
                WorkflowFactory.getInstance().deleteWorkflowsForOption(getAttributeOption(), 
                                             module, issueType);

                // ======================================================
                // Correct the ordering of the remaining options
                // ======================================================

                // first retrieve the list of still available option ids
                final List optIds = new ArrayList();
                final List rmos = module.getRModuleOptions(getAttributeOption().getAttribute(), issueType, false);
                for (int i=0; i<rmos.size();i++)
                {
                    final RModuleOption rmo = (RModuleOption)rmos.get(i);
                    optIds.add(rmo.getOptionId());
                }
               
                // Need to perform the correction only if the deleted option had follow up options
                if(optIds.size() > 0)
                {
                    // update the list
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID,       moduleId)
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,   issueTypeId)
                        .addIn(RModuleOptionPeer.OPTION_ID,     optIds)
                        .add(RModuleOptionPeer.PREFERRED_ORDER, orderNumber, Criteria.GREATER_THAN);
                    final List adjustRmos = RModuleOptionPeer.doSelect(c2);
                    for (int j=0; j<adjustRmos.size();j++)
                    {
                        final RModuleOption rmo = (RModuleOption)adjustRmos.get(j);
                        //rmos.remove(rmo);
                        rmo.setOrder(rmo.getOrder() -1);
                        rmo.save();
                        //rmos.add(rmo);
                    }
                }
            }
            // notify module cache of this change
            ((ModuleManager)Torque.getManager(ModuleManager.MANAGED_CLASS))
                .refreshedObject(this);
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected ScarabUser getInstanceByEmailImpl(final String email) 
        throws TorqueException,ScarabException
    {
        ScarabUser user = null;
        if (email != null) 
        {
            final Criteria crit = new Criteria();
            crit.add(ScarabUserImplPeer.EMAIL, email);
            final List users = ScarabUserImplPeer.doSelect(crit);
            if (users.size() == 1) 
            {
                user = (ScarabUser)users.get(0);
            }
            else if (users.size() > 1) 
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateUsername); 
            }
        }
        return user;
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public void save()
        throws TorqueException, ScarabException
    {
        AttributeOption ao = null;
        ROptionOption roo = null;

        final Attribute tmpAttr = AttributeManager.getInstance(getAttributeId());
        
        // if it is new, it won't already have an optionId
        if (getOptionId() == null)
        {
            // if it is new, check for duplicates.
            final AttributeOption duplicate = 
                AttributeOptionManager.getInstance(tmpAttr, getName().trim());
            final AttributeOption parent = 
                AttributeOptionManager.getInstance(getParentId());
            if (duplicate != null)
            {
                throw new ScarabException (new L10NKey("CannotCreateDuplicateOption")); //EXCEPTION
            }
            else if (parent.getDeleted())
            {
                throw new ScarabException (new L10NKey("CannotCreateChild")); //EXCEPTION
            }
        }

        // if getOptionId() is null, then it will just create a new instance
        final Integer optionId = getOptionId();
        if (optionId == null)
        {
            ao = AttributeOptionManager.getInstance();
        } 
        else
        {
            ao = AttributeOptionManager.getInstance(getOptionId());
        }

        
        ao.setName(getName());
        ao.setDeleted(getDeleted());
        ao.setAttribute(tmpAttr);
        ao.setStyle(getStyle());
        ao.save();

        // clean out the caches for the AO
        tmpAttr.doRemoveCaches();

        // now set our option id from the saved AO
        this.setOptionId(ao.getOptionId());

        // now create the ROO mapping
        try
        {
            // look for a cached ROptionOption
            roo = ROptionOption.getInstance(getParentId(), getOptionId());
        }
        catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
        roo.setPreferredOrder(getPreferredOrder());
        roo.setWeight(getWeight());
        roo.setRelationshipId(OptionRelationship.PARENT_CHILD);
        roo.save();
    }
              
// in java/org/tigris/scarab/om/ROptionOption.java
public static ROptionOption getInstance(final Integer parent, final Integer child)
        throws ScarabException
    {
    	ROptionOption option = null;
    	try
        {
    	    final Criteria crit = new Criteria();
            crit.add (ROptionOptionPeer.OPTION1_ID, parent);
            crit.add (ROptionOptionPeer.OPTION2_ID, child);
            option = (ROptionOption) (ROptionOptionPeer.doSelect(crit)).get(0);
        }
        catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
        return option;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public IssueType getTemplateIssueType()
        throws TorqueException, ScarabException
    {
        if (templateIssueType == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.PARENT_ID, getIssueTypeId());
            final List results = IssueTypePeer.doSelect(crit);
            if (results.isEmpty())
            {
                throw new ScarabException(L10NKeySet.ExceptionTemplateTypeForIssueType);
            }
            else
            {
                templateIssueType = (IssueType)results.get(0);
            }
        }
        return templateIssueType;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public static IssueType getInstance(final String issueTypeName)
        throws TorqueException,ScarabException
    {
        IssueType result = null;
        Object obj = ScarabCache.get(ISSUE_TYPE, GET_INSTANCE, issueTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.NAME, issueTypeName);
            final List issueTypes = IssueTypePeer.doSelect(crit);
            if(issueTypes == null || issueTypes.size() == 0)
            {
                throw new ScarabException(L10NKeySet.ExceptionInvalidIssueType,
                                          issueTypeName);
            }
            result = (IssueType)issueTypes.get(0);
            ScarabCache.put(result, ISSUE_TYPE, GET_INSTANCE, issueTypeName);
        }
        else 
        {
            result = (IssueType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user)
        throws ScarabException
    {
        int count = 0;
        try 
        {
            IssueSearch is = IssueSearchFactory.INSTANCE
                .getInstance(getModule(), getIssueType(), user);
            count = is.getIssueCount();
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
        return count;
    }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(NotificationStatus notif) throws ScarabException
    {
        NotificationRule rule = null;
        try
        {
            Long issueId = notif.getIssueId();
            Issue issue = IssueManager.getInstance(issueId);
            Integer moduleId = issue.getModuleId();
            Integer userId = notif.getReceiverId();
            ActivityType activityType = notif.getActivityType();
            rule = getNotificationRule(moduleId, userId, activityType.getCode());
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
        return rule;
    }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(Integer moduleId, Integer userId, String activityType) throws ScarabException
    {
        NotificationRule rule = null;
        
        int managerId = NotificationManagerFactory.getInstance().getManagerId();
        Criteria crit = new Criteria();
        crit.add(NotificationRulePeer.USER_ID, userId);
        crit.add(NotificationRulePeer.MODULE_ID, moduleId);
        crit.add(NotificationRulePeer.ACTIVITY_TYPE, activityType);
        crit.add(NotificationRulePeer.MANAGER_ID, managerId);
                
        try
        {
            List<NotificationRule> ruleSet = (List<NotificationRule>)NotificationRulePeer.doSelect(crit);     
            if(ruleSet == null || ruleSet.size()==0)
            {

                rule = NotificationRule.createDefaultRule( 
                       moduleId, 
                       userId,
                       managerId,
                       activityType);
            }
            else if (ruleSet.size() > 1)
            {
                String msg = "Database inxonsistency:"
                           + " Expected at most one key matching (user_id,module_id,activity_type,manager_id) = "
                           + ")" + userId + "," + moduleId + "," + activityType + "," + managerId + ")";
                throw new TorqueException(msg,new Throwable());
            }
            else
            {
                rule = ruleSet.get(0);
            }
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }

        return rule;
    }
              
// in java/org/tigris/scarab/om/RIssueTypeOption.java
public void delete(final ScarabUser user, final Module module)
         throws TorqueException, ScarabException
    {                
        if (user.hasPermission(ScarabSecurity.DOMAIN__EDIT, module))
        {
            final List rios = getIssueType().getRIssueTypeOptions(
                                      getAttributeOption().getAttribute(), false);
            final Criteria c = new Criteria()
                .add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
            RIssueTypeOptionPeer.doDelete(c);
            rios.remove(this);
            if (rios.size() > 0)
            {
                // Correct the ordering of the remaining options
                final ArrayList optIds = new ArrayList();
                for (int i=0; i<rios.size();i++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)rios.get(i);
                    optIds.add(rio.getOptionId());
                }
                final Criteria c2 = new Criteria()
                    .addIn(RIssueTypeOptionPeer.OPTION_ID, optIds)
                    .add(RIssueTypeOptionPeer.PREFERRED_ORDER, getOrder(), 
                         Criteria.GREATER_THAN);
                final List adjustRios = RIssueTypeOptionPeer.doSelect(c2);
                for (int j=0; j<adjustRios.size();j++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)adjustRios.get(j);
                    rio.setOrder(rio.getOrder() -1);
                    rio.save();
                }
            }
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public ScarabUser[] getEligibleUsers(Attribute attribute)
        throws TorqueException,ScarabException
    {
        ScarabUser[] users = null;
        if (attribute.isUserAttribute()) 
        {
            String permission = attribute.getPermission();
            if (permission == null) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionNoAttributePermission,
                        attribute.getName());
            }
            else 
            {
                users = getUsers(permission);
            }
        }
        return users;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getSavedReports(final ScarabUser user)
        throws TorqueException,ScarabException
    {
        List reports = null;
        final Object obj = ScarabCache.get(this, GET_SAVED_REPORTS, user); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria()
                .add(ReportPeer.DELETED, 0);
            final Criteria.Criterion cc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.MODULE__PK, Criteria.EQUAL);
            cc.and(crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL));
            final Criteria.Criterion personalcc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.PERSONAL__PK, Criteria.EQUAL);
            personalcc.and(crit.getNewCriterion(
                ReportPeer.USER_ID, user.getUserId(), Criteria.EQUAL));
            final Criteria.Criterion personalmodulecc = crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL);
            personalmodulecc.or(crit.getNewCriterion(
                ReportPeer.MODULE_ID, null, Criteria.EQUAL));
            personalcc.and(personalmodulecc);
            cc.or(personalcc);
            crit.add(cc);
            crit.addAscendingOrderByColumn(ReportPeer.SCOPE_ID);
            final List torqueReports = ReportPeer.doSelect(crit);      
            // create ReportBridge's from torque Reports.
            if (!torqueReports.isEmpty()) 
            {
                reports = new ArrayList(torqueReports.size());
                for (Iterator i = torqueReports.iterator(); i.hasNext();) 
                {
                    final Report torqueReport = (Report)i.next();
                    try 
                    {
                        reports.add( new ReportBridge(torqueReport) );
                    }
                    catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }     
                    catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
                }
            }
            else 
            {
                reports = Collections.EMPTY_LIST;
            }

            ScarabCache.put(reports, this, GET_SAVED_REPORTS, user);
        }
        else 
        {
            reports = (List)obj;
        }
        return reports;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/ActivitySetTypeManager.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException,ScarabException
    {
        ActivitySetType ttype = null; 
        Object obj = ScarabCache.get(TRANSACTION_TYPE, GET_INSTANCE, 
                                     activitySetTypeName);
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(ActivitySetTypePeer.NAME, activitySetTypeName);
            final List activitySetTypes = ActivitySetTypePeer.doSelect(crit);
            if (activitySetTypes.size() < 1) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetTypenameNotFound, 
                        activitySetTypeName);
            }
            if (activitySetTypes.size() > 1)
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetDuplicateTypename,
                        activitySetTypeName);
            }
            ttype = (ActivitySetType)activitySetTypes.get(0);
            ScarabCache.put(ttype, "ActivitySetType", "getInstance", 
                            activitySetTypeName);
        }
        else 
        {
            ttype = (ActivitySetType)obj;
        }
        
        return ttype;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(ActivitySet activitySet, 
                                  Attachment attachment, ScarabUser user)
        throws TorqueException, ScarabException
    {
        String comment = attachment.getData();
        if (comment == null || comment.length() == 0)
        {
            throw new ScarabException(L10NKeySet.NoDataInComment);
        }

        activitySet = attachActivitySet(activitySet, user);

        // populates the attachment with data to be a comment
        attachment = AttachmentManager
                        .getComment(attachment, this, user);

        ActivityManager
            .createTextActivity(this, activitySet,
                                ActivityType.COMMENT_ADDED, attachment);

        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.COMMENT_ADDED, activitySet, this, user);            

        index();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doAddDependency(ActivitySet activitySet, Depend depend, 
                                       Issue childIssue, ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check whether the entered issue is already dependent on this
        // Issue. If so, then throw an exception because we don't want
        // to add it again.
        Depend prevDepend = this.getDependency(childIssue, true);
        if (prevDepend != null)
        {
            throw new ScarabException(L10NKeySet.DependencyExists);
        }

        // we definitely want to do an insert here so force it.
        depend.setNew(true);
        depend.setDeleted(false);
        depend.save();

        Attachment comment = depend.getDescriptionAsAttachment(user, this);
        activitySet = attachActivitySet(activitySet, user, comment);

        // Save activity record for the parent issue
        ActivityManager
            .createAddDependencyActivity(this, activitySet, depend);

        // Save activity record for the child issue
        ActivityManager
            .createAddDependencyActivity(childIssue, activitySet, depend);

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private int getNextIssueId(Connection con)
        throws TorqueException, ScarabException
    {
        int id = -1;
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        try
        {
            id = idbroker.getIdAsInt(con, key);
        }
        catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
        return id;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private void setNextIssueId(Connection con, int newID)
        throws TorqueException, ScarabException
    {
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        int nextID = 1;
        
        synchronized (idbroker)
        {
            try
            {
                // Check if the ID table is available and get the next ID
                nextID = idbroker.getIdAsInt(con, key);
            }
            catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }

            if (nextID > newID) {
                getLog()
                    .error("New issue ID "+ newID
                    + "is out of sequence. Must be at least " + nextID);
            }
            else
            {
                try
                {
                    // Now set the next available ID in the table
                    setIdTableKey(con, newID);
                }
                catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Issue move(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user,
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
    	
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // If moving to a new issue type, just change the issue type id
        // otherwise, create fresh issue
        if (getModule().getModuleId().equals(newModule.getModuleId())
            && !getIssueType().getIssueTypeId().equals(newIssueType.getIssueTypeId()))
        {
            newIssue = this;
            newIssue.setIssueType(newIssueType);
            newIssue.save();
        }
        else
        {
            newIssue = newModule.getNewIssue(newIssueType);
        }

        if (newIssue != this)//new issue is not same issue instance as old issue
        {
            // mark issue as moved
            setMoved(true);
            save();

            //add new transaction to new issue
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();      

            // copy attachments: comments/files etc.
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                String oldFilePath = oldA.getFullPath();
                oldA.setIssueId(newIssue.getIssueId());
                oldA.save();
                
                // move file attachment, too
                if (Attachment.FILE__PK.equals(oldA.getTypeId())
                		&& !newIssue.getUniqueId().equals(this.getUniqueId()))
                {
                    try
                    {
                        oldA.copyFileFromTo(oldFilePath, oldA.getFullPath());//copy
                        File f = new File(oldFilePath);//delete old one from disk
                        f.delete();
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }

            // Copy over activity sets for the source issue's previous,
            // and adapt them to new issue
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();

                // If activity set has an attachment, make a copy for new issue
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    // iterate over and move transaction's activities
                    final Activity a = (Activity)j.next();
                    
                    // Only copy transactions that are records of previous move/copies
                    // or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // will be saved when attachments and dependencies are copied.
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                            || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                    	att.setIssueId(newIssue.getIssueId());
                                    	att.setActivity(a);
                                    	att.startActivitySet(as);
                                    	att.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            //adapt all misc activities from old issue
            Iterator iterActivities = getActivitys().iterator();
            while(iterActivities.hasNext()){
            	Activity act = (Activity)iterActivities.next();
            	act.setIssue(newIssue);
            	act.save();
            	newIssue.getActivity(true).add(act); // ?
            }
            
            // Adjust dependencies if its a new issue id
            // (i.e.. moved to new module)
           final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
        }       
       

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "MovedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());

        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "MovedIssueNote"));
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_MOVED,
                                getUniqueId(), newIssue.getUniqueId());

        newIssue.index();
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_MOVED,
                activitySet2, newIssue, user);
        
        return newIssue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Issue copy(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user, 
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // create fresh issue
        newIssue = newModule.getNewIssue(newIssueType);

        if (newIssue != this)
        {
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();

            // Copy over activity sets for the source issue's attribute activities
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();
                ActivitySet newAS = null;
                Attachment newAtt =  null;
                              
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    final Activity a = (Activity)j.next();

                    // Only copy transactions that are records of previous move/copies
                    // Or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // Will be saved when attachments and dependencies are copied
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                        || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // iterate over and copy transaction's activities
                       
                        if(newAS == null){
                        	
                        	 // If old activity set has an attachment, make a copy for new issue
                            if (as.getAttachmentId() != null)
                            {
                                newAtt = as.getAttachment().copy();
                                newAtt.save();
                            }
                        	
            				//init and store new activity set/transaction
                            newAS = new ActivitySet();
                            newAS.setTypeId(as.getTypeId());
                            if (newAtt != null)
                            {
                                newAS.setAttachmentId(newAtt.getAttachmentId());
                            }
                            newAS.setCreatedBy(as.getCreatedBy());
                            newAS.setCreatedDate(as.getCreatedDate());
                            newAS.save();
                        }
                        
                        final Activity newA = a.copy(newIssue, newAS);
                        
                        newIssue.getActivity(true).add(newA);
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                        final AttributeValue newAttVal = att.copy();
                                        newAttVal.setIssueId(newIssue.getIssueId());                                        
                                        newAttVal.setActivity(newA);
                                        newAttVal.startActivitySet(newAS);
                                        newAttVal.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            // add dependencies newly
            final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
            // copy attachments: comments/files etc. and add them, too
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                final Attachment newA = oldA.copy();
                newA.setIssueId(newIssue.getIssueId());
                newA.save();
                final Activity oldAct = oldA.getActivity();
                if (oldAct != null)
                {
                    final ActivitySet activitySet = newIssue.attachActivitySet(null, user);
                    ActivityManager.createTextActivity(newIssue, activitySet,
                        ActivityType.getActivityType(oldA.getActivity().getActivityType()), newA);
                }
                if (Attachment.FILE__PK.equals(newA.getTypeId()))
                {
                    try
                    {
                        oldA.copyFileTo(newA.getFullPath());
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }
        }

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CopiedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());


        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "CopiedIssueNote"));
        
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        // NOTE: There is no distinction bewteen copy and move actions in ActivitySetTypePeer.
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_COPIED,
                                getUniqueId(), newIssue.getUniqueId());
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_COPIED,
                activitySet2, newIssue, user);
        
        newIssue.index();
        
        return newIssue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void addVote(ScarabUser user)
        throws ScarabException, Exception
    {
        // check to see if the user has voted for this issue
        int previousVotes = 0;
        IssueVote issueVote = null;
        Criteria crit = new Criteria()
            .add(IssueVotePeer.ISSUE_ID, getIssueId())
            .add(IssueVotePeer.USER_ID, user.getUserId());
        List votes = IssueVotePeer.doSelect(crit);
        if (votes != null && votes.size() != 0) 
        {
            issueVote = (IssueVote)votes.get(0);
            previousVotes = issueVote.getVotes();
        }
        else 
        {
            issueVote = new IssueVote();
            issueVote.setIssueId(getIssueId());
            issueVote.setUserId(user.getUserId());
        }

        // check if the module accepts multiple votes
        if (!getModule().allowsMultipleVoting() && previousVotes > 0)
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleVoteForUnallowed,
                                      user.getUserName(), 
                                      getUniqueId());
        }
        
        // save the user's vote
        issueVote.setVotes(previousVotes+1);
        issueVote.save();

        // update the total votes for the issue
        crit = new Criteria()
            .add(AttributeValuePeer.ATTRIBUTE_ID, 
                 AttributePeer.TOTAL_VOTES__PK);
        List voteValues = getAttributeValues(crit);
        TotalVotesAttribute voteValue = null;
        if (voteValues.size() == 0) 
        {
            voteValue = new TotalVotesAttribute();
            voteValue.setIssue(this);
            voteValue.setAttributeId(AttributePeer.TOTAL_VOTES__PK);
        }
        else 
        {
            voteValue = (TotalVotesAttribute)voteValues.get(0);
        }
        // Updating attribute values requires a activitySet
        ActivitySet activitySet = attachActivitySet(null, user, null, 
           ActivitySetTypePeer.RETOTAL_ISSUE_VOTE__PK);
        voteValue.startActivitySet(activitySet);
        voteValue.addVote();
        voteValue.save();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void deleteItem(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__DELETE, module)
            || (user.getUserId().equals(getCreatedBy().getUserId()) && isTemplate()))
        {
            setDeleted(true);
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setInitialAttributeValues(ActivitySet activitySet, 
            Attachment attachment, 
            final HashMap newValues, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check new values for workflow
        final String msg = doCheckInitialAttributeValueWorkflow(newValues, user);
        if (msg != null)
        {
            throw new TorqueException(msg); //EXCEPTION
        }
        
        if (activitySet == null)
        {
            // Save activitySet record
            activitySet = ActivitySetManager
                .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
            activitySet.save();
        }
        setActivitySetRelatedByCreatedTransId(activitySet);

        // enter the values into the activitySet
        final LinkedMap avMap = getModuleAttributeValuesMap(); 
        final MapIterator iter = avMap.mapIterator();
        while (iter.hasNext())
        {
            final AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            try
            {
                aval.startActivitySet(activitySet);
            }
            catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
        }        
        this.save();

        // create initial issue creation activity
        ActivityManager.createReportIssueActivity(this, activitySet,  
                Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueCreated"));

        // this needs to be done after the issue is created.
        // check to make sure the attachment has data before submitting it.
        final String attachmentData = attachment.getData();
        if (attachmentData != null &&
            attachmentData.length() > 0)
        {
            attachment = AttachmentManager.getReason(attachment, this, user);
            activitySet.setAttachment(attachment);
        }
        activitySet.save();
        
        // need to clear the cache since this is after the 
        // issue is saved. for some reason, things don't
        // show up properly right away.
        ScarabCache.clear();
        
        index();
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setAttributeValues(ActivitySet activitySet,
                                          final HashMap newAttVals,
                                          final Attachment attachment,
                                          final ScarabUser user)
        throws TorqueException,ScarabException
    {
        if (!isTemplate())
        {
            final String msg = doCheckAttributeValueWorkflow(newAttVals, user);
            if (msg != null)
            {
                throw new ScarabException(L10NKeySet.ErrorExceptionMessage,msg); 
            }
        }
        if (attachment != null)
        {
            attachment.setTextFields(user, this, 
                                     Attachment.MODIFICATION__PK);
            attachment.save();
        }
        activitySet = attachActivitySet(activitySet, user, attachment );
        
        final LinkedMap avMap = getModuleAttributeValuesMap(true); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            final String newAttValValue = newAttVal.getValue();

            if (oldAttVal != null &&
            		(newAttValValue != null && !newAttValValue.equals(oldAttVal.getValue())
            		 || newAttValValue == null)
            		 )
            {
                if (newAttValValue != null && newAttValValue.length() > 0)
                {
                    oldAttVal.setProperties(newAttVal);
                }
                else
                {
                    oldAttVal.setDeleted(true);
                }
                oldAttVal.startActivitySet(activitySet);
                oldAttVal.save();
            }
        }
        index();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public List<Activity> getActivityList() throws ScarabException
    {
        List<Activity> result = null;
/* FIXME: caching is disabled here because new Activities can be
          added to this activityset and the addition does not trigger 
          a reset of this cache (JSS).
        Object obj = ScarabCache.get(this, GET_ACTIVITY_LIST); 
        if (obj == null) 
        {
*/
            Criteria crit = new Criteria()
                .add(ActivityPeer.TRANSACTION_ID, getActivitySetId());
            try
            {
                result = ActivityPeer.doSelect(crit);
            }
            catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
//            ScarabCache.put(result, this, GET_ACTIVITY_LIST);
/*
        }
        else 
        {
            result = (List)obj;
        }
*/
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                       final Attribute attribute,
                                                       final IssueType issueType)
        throws TorqueException, ScarabException
    {
        RModuleUserAttribute result = null;
        final Object obj = ScarabCache.get(this, GET_R_MODULE_USERATTRIBUTE, 
                                     module, attribute, issueType); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria(4)
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId())
                .add(RModuleUserAttributePeer.LIST_ID, null);
            if (module == null) 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, 
                         module.getModuleId());
                
            }            
            if (issueType == null) 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                         issueType.getIssueTypeId());                
            }
            
            final List muas = RModuleUserAttributePeer.doSelect(crit);
            if (muas.size() == 1) 
            {
                result = (RModuleUserAttribute)muas.get(0);
            }
            else if (muas.isEmpty())
            {
                result = 
                    getNewRModuleUserAttribute(attribute, module, issueType);
            }
            else 
            {
                throw new ScarabException(L10NKeySet.ExceptionMultipleJDMs);
            }
            ScarabCache.put(result, this, GET_R_MODULE_USERATTRIBUTE, 
                            module, attribute, issueType);
        }
        else 
        {
            result = (RModuleUserAttribute)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public String setReportingIssue(Issue issue)
        throws ScarabException
    {
        String key = null;
        if (issue == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNullIssueForbidden);
        }
        else 
        {
            key = String.valueOf(issueCount++);
            setReportingIssue(key, issue);
        }
        return key;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public String setCurrentReport(ReportBridge report)
        throws ScarabException
    {
        String key = null;
        if (report == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNullReportForbidden);
        }
        else 
        {
            key = String.valueOf(reportCount++);
            setCurrentReport(key, report);
        }
        return key;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void setHomePage(final String homePage)
        throws TorqueException, ScarabException
    {
        if ("ModuleNotReady.vm".equals(homePage)) 
        {
            throw new ScarabException(L10NKeySet.ExceptionForbiddenHomeModuleNotReady);
        }
        final UserPreference up = UserPreferenceManager.getInstance(getUserId());
        up.setHomePage(homePage);
        up.save();
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public String getRelativePath()
        throws TorqueException,ScarabException
    {
        if (isNew()) 
        {
            throw new ScarabException(L10NKeySet.ExceptionPathNotSet);
        }        
        String path = null;
        String filename = getFileName();
        if (filename != null) 
        {
            // moduleId/(issue_IdCount/1000)/issueID_attID_filename
            StringBuffer sb = new StringBuffer(30 + filename.length());
            final Issue issue = getIssue();
            sb.append("mod").append(issue.getModule().getQueryKey())
                .append(File.separator)
                .append(issue.getIdCount() / 1000)
                .append(File.separator)
                .append(issue.getUniqueId()).append('_')
                .append(getQueryKey()).append('_')
                .append(filename);
            path = sb.toString();
        }
        return path;
    }
              
// in java/org/tigris/scarab/om/ReportPeer.java
public static Report retrieveByName(final String name)
        throws TorqueException, ScarabException
    {
        Report report = null;
        final Criteria crit = new Criteria()
            .add(NAME, name)
            .add(DELETED, false);
        final List reports = doSelect(crit);
        if (reports.size() == 1) 
        {
            report = (Report)reports.get(0);
        }
        else if (reports.size() > 1) 
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleReports,
                                      name);
        }
        
        return report;
    }
              
// in java/org/tigris/scarab/om/AttributeType.java
public static AttributeType getInstance(final String attributeTypeName) 
        throws TorqueException, ScarabException
    {
        AttributeType result = null;
        final Object obj = ScarabCache.get(ATTRIBUTETYPE, GET_INSTANCE, 
                                     attributeTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(AttributeTypePeer.ATTRIBUTE_TYPE_NAME, attributeTypeName);
            final List attributeTypes = AttributeTypePeer.doSelect(crit);
            if(attributeTypes.size() > 1)
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateAttributeTypeName,
                                          attributeTypeName);
            }
            result = (AttributeType)attributeTypes.get(0);
            ScarabCache.put(result, ATTRIBUTETYPE, GET_INSTANCE, 
                            attributeTypeName);
        }
        else 
        {
            result = (AttributeType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Depend.java
public void setObserverUniqueId(String uniqueId)
         throws TorqueException, ScarabException
    {
        if (getDefaultModule() == null)
        {
            throw new ScarabException( L10NKeySet.ExceptionDependInternalWorkflow,
                                       "setDefaultModule()",
                                       "setObserverUniqueId()");
        }
        Issue childIssue = IssueManager.getIssueById(uniqueId.trim());
        if (childIssue == null)
        {
           String code = getDefaultModule().getCode();
           uniqueId = code + uniqueId;
           childIssue = IssueManager.getIssueById(uniqueId);
        }
        super.setObserverId(childIssue.getIssueId());
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped template, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        boolean success = true;
        final Issue issue = IssueManager.getInstance(getIssueId());

        // If it's a module template, user must have Item | Approve 
        //   permission, or its Approved field gets set to false
        if (getScopeId().equals(Scope.PERSONAL__PK)
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        } 
        else
        {
            setApproved(false);
            issue.save();

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");
                
                ScarabUser[] toUsers = module.getUsers(ScarabSecurity.MODULE__EDIT);
                // if the module doesn't have any users, then we need to add at 
                // least ourselves...
                if (toUsers.length == 0)
                {
                    toUsers = new ScarabUser[1];
                    toUsers[0] = user;
                }

                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewTemplateRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx, 
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null, template);
                }
                catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            }
        }
        save();
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getIssue().getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void delete(final ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        final IssueType issueType = getIssueType();

        if (user.hasPermission(ScarabSecurity.MODULE__CONFIGURE, module))
        {
            // Delete both active and inactive attribute groups first
            final List attGroups = issueType.getAttributeGroups(module, false);
            for (int j=0; j<attGroups.size(); j++)
            {
                // delete attribute-attribute group map
                final AttributeGroup attGroup = 
                              (AttributeGroup)attGroups.get(j);
                attGroup.delete();
            }

            // Delete mappings with user attributes
            List rmas = module.getRModuleAttributes(issueType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
            // Delete mappings with user attributes for template type
            final IssueType templateType = issueType.getTemplateIssueType();
            rmas = module.getRModuleAttributes(templateType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
 
            // delete workflows
            WorkflowFactory.getInstance().resetAllWorkflowsForIssueType(module, 
                                                                        issueType);
            // delete templates
            Criteria c = new Criteria()
                .add(IssuePeer.TYPE_ID, templateType.getIssueTypeId());
            final List result = IssuePeer.doSelect(c);
            final List issueIdList = new ArrayList(result.size());
            for (int i=0; i < result.size(); i++) 
            {
                final Issue issue = (Issue)result.get(i);
                issueIdList.add(issue.getIssueId());
            }
            IssuePeer.doDelete(c);
            if (!issueIdList.isEmpty())
            {
                c = new Criteria()
                    .addIn(IssueTemplateInfoPeer.ISSUE_ID, issueIdList);
                IssueTemplateInfoPeer.doDelete(c);
            }
            
            // mit list items
            c = new Criteria()
                .add(MITListItemPeer.MODULE_ID, module.getModuleId())
                .add(MITListItemPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
            final List listItems = MITListItemPeer.doSelect(c);
            final List listIds = new ArrayList(listItems.size());

            for (int i=0; i < listItems.size(); i++) 
            {
                final MITList list = ((MITListItem)listItems.get(i)).getMITList();
                final Long listId = list.getListId();
                if (list.isSingleModuleIssueType() && !listIds.contains(listId))
                {
                    listIds.add(listId);
                }
            }
            MITListItemPeer.doDelete(c);

            if (!listIds.isEmpty())
            {
                // delete single module-issuetype mit lists
                c = new Criteria()
                    .addIn(MITListPeer.LIST_ID, listIds);
                MITListPeer.doDelete(c);

                // delete queries
                c = new Criteria()
                    .addIn(QueryPeer.LIST_ID, listIds);
                QueryPeer.doDelete(c);
            }

            c = new Criteria()
                .add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .add(RModuleIssueTypePeer.ISSUE_TYPE_ID, getIssueTypeId());
            RModuleIssueTypePeer.doDelete(c);
            RModuleIssueTypeManager.removeFromCache(this);
            final List rmits = module.getRModuleIssueTypes();
            rmits.remove(this);
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void delete()
         throws TorqueException, ScarabException
    {                
        int dupeSequence = 0;
        final Integer issueTypeId = getIssueTypeId();
        final IssueType issueType = IssueTypeManager
            .getInstance(SimpleKey.keyFor(issueTypeId), false);
        List attrGroups = null;

        if (isGlobal())
        {
            attrGroups = issueType.getAttributeGroups(null, false);
            dupeSequence =  issueType.getDedupeSequence();
            // Delete issuetype-attribute mapping
            final Criteria crit  = new Criteria()
                .addJoin(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                         RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                .add(RAttributeAttributeGroupPeer.GROUP_ID,
                     getAttributeGroupId())
                .add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, issueTypeId);
            final List results = RIssueTypeAttributePeer.doSelect(crit);
            for (Iterator i = results.iterator(); i.hasNext();)
            {
                ((RIssueTypeAttribute)i.next()).delete();
            }
        }
        else
        {
            if (issueType.getLocked())
            { 
                
                throw new ScarabException(L10NKeySet.ExceptionGroupDeleteForbidden,
                          this.getName(),
                          issueType.getName());
            }            
            else
            {
                final Module module = getModule();
                attrGroups = getIssueType().getAttributeGroups(module, false);
                dupeSequence =  module.getDedupeSequence(issueType);
                // Delete module-attribute mapping
                final Criteria crit  = new Criteria()
                    .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                             RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                    .add(RAttributeAttributeGroupPeer.GROUP_ID,
                             getAttributeGroupId())
                    .add(RModuleAttributePeer.MODULE_ID,
                         getModuleId());
                final Criteria.Criterion critIssueType = crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                getIssueTypeId(), Criteria.EQUAL);
                critIssueType.or(crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                issueType.getTemplateId(), Criteria.EQUAL));
                crit.and(critIssueType);
                final List results = RModuleAttributePeer.doSelect(crit);
                for (int i=0; i<results.size(); i++)
                {
                    final RModuleAttribute rma = (RModuleAttribute)results.get(i);
                    rma.delete();
                }
            }
        }

        // Delete attribute - attribute group mapping
        Criteria crit2 = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, getAttributeGroupId());
        RAttributeAttributeGroupPeer.doDelete(crit2);


        // Delete the attribute group
        final int order = getOrder();
        crit2 = new Criteria()
            .add(AttributeGroupPeer.ATTRIBUTE_GROUP_ID, getAttributeGroupId());
        AttributeGroupPeer.doDelete(crit2);
        IssueTypeManager.getManager().refreshedObject(this);
            
        // Adjust the orders for the other attribute groups
        for (int i=0; i<attrGroups.size(); i++)
        {
            final AttributeGroup tempGroup = (AttributeGroup)attrGroups.get(i);
            int tempOrder = tempGroup.getOrder();
            if (tempGroup.getOrder() > order)
            {
                if (tempOrder == dupeSequence + 1 && tempOrder == 3)
                {
                    tempGroup.setOrder(tempOrder - 2);
                }
                else
                {
                    tempGroup.setOrder(tempOrder - 1);
                }
                tempGroup.save();
            }
        } 
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void deleteAttribute(final Attribute attribute, 
            final ScarabUser user,
            final Module module)
         throws TorqueException, ScarabException
    {                
        String permission = null;
        if (isGlobal())
        {
            permission = (ScarabSecurity.DOMAIN__EDIT);
        }
        else
        {
            permission = (ScarabSecurity.MODULE__CONFIGURE);
        }
        if (user.hasPermission(permission, module))
        {
            final IssueType issueType = getIssueType();
            final IssueType template = IssueTypeManager.getInstance
                                 (issueType.getTemplateId());
            boolean success = true;

            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
            if (isGlobal())
            {
                // This is a global attribute group
                // Remove attribute - issue type mapping
                final List rias = issueType.getRIssueTypeAttributes
                                     (false, AttributePeer.NON_USER);
                if (ria != null) 
                {
                    ria.delete();                    
                }
                if (rias != null) 
                {
                    rias.remove(ria);        
                }
            }
            else
            {
                // Check if attribute is locked
                if (ria != null && ria.getLocked())
                {
                    success = false;
                    throw new TorqueException(attribute.getName() + "is locked"); //EXCEPTION
                }
                else
                {
                    // Remove attribute - module mapping
                    final List rmas = module.getRModuleAttributes(issueType, false,
                                                            AttributePeer.NON_USER);    
                    final RModuleAttribute rma = module
                        .getRModuleAttribute(attribute, issueType);
                    if(rma != null)rma.delete();
                    WorkflowFactory.getInstance().deleteWorkflowsForAttribute
                                                  (attribute, module, issueType);
                    if(rma != null)rmas.remove(rma);

                    // Remove attribute - module mapping from template type
                    final RModuleAttribute rma2 = module
                                   .getRModuleAttribute(attribute, template);
                    if(rma2 != null)
                    {
                        rma2.delete();
                        rmas.remove(rma2);
                    }
                }
            }

            if (success)
            {
                // Remove attribute - group mapping
                final RAttributeAttributeGroup raag = 
                    getRAttributeAttributeGroup(attribute);
                raag.delete();

                if (attribute.isOptionAttribute())
                {
                    if (isGlobal())
                    { 
                        // global attributeGroup; remove issuetype-option maps
                        final List rios = issueType.getRIssueTypeOptions(attribute);
                        if (rios != null)
                        {
                            for (int i = 0; i<rios.size();i++)
                            {
                                ((RIssueTypeOption) rios.get(i))
                                    .delete(user, module);
                            }
                        }
                    }
                    else
                    {
                        // Remove module-option mapping
                        final List rmos = module.getRModuleOptions(attribute, issueType);
                        if (rmos != null)
                        {
                            rmos.addAll(module.getRModuleOptions(attribute, template));
                            for (int j = 0; j<rmos.size();j++)
                            {
                                final RModuleOption rmo = (RModuleOption)rmos.get(j);
                                 // rmo's may be inherited by the parent module.
                                 // don't delete unless they are directly associated
                                 // with this module.  Will know by the first one.
                                 if (rmo.getModuleId().equals(module.getModuleId())) 
                                 {
                                     rmo.delete();
                                 }
                                 else 
                                 {
                                     break;
                                 } 
                             }
                         }
                     }
                 }
             }
         }
         else
         {
             throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
         }            
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
              
// in java/org/tigris/scarab/om/AttachmentType.java
public static AttachmentType getInstance(String attachmentTypeName)
        throws TorqueException,ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(BaseAttachmentTypePeer.ATTACHMENT_TYPE_NAME, attachmentTypeName);
        List attachmentTypes = AttachmentTypePeer.doSelect(crit);
        if(attachmentTypes.size() > 1)
        {
            throw new ScarabException(L10NKeySet.ExceptionAttachmentDuplicateTypename);
        }
        return (AttachmentType)attachmentTypes.get(0);
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public List getTransitions(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        Module module = user.getCurrentModule();
        List result = null;
        List availableOptions = getAvailableOptions(issueType, attribute, module);

        Iterator optionsIter = availableOptions.iterator();
        while(optionsIter.hasNext())
        {
            RModuleOption rmoduleOption = (RModuleOption)optionsIter.next();
            AttributeOption fromOption;
            try
            {
                fromOption = rmoduleOption.getAttributeOption();
            }
            catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            List list = getTransitionsFrom(user,issueType,attribute,fromOption);
            if(list != null)
            {
                if(result == null)
                {
                    result = list;
                }
                else
                {
                    result.addAll(list);
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public TransitionNode getTransitionTree(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        Module module = user.getCurrentModule();
        TransitionNode result = null;
        List availableOptions = getAvailableOptions(issueType, attribute, module,false);
        List visitedTransitions = null;
        Iterator optionsIter = availableOptions.iterator();
        while(optionsIter.hasNext())
        {
            RModuleOption rmoduleOption = (RModuleOption)optionsIter.next();
            AttributeOption fromOption;
            try
            {
                fromOption = rmoduleOption.getAttributeOption();
            }
            catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            List list = getTransitionsFrom(user,issueType,attribute,fromOption,false);
            if(list != null)
            {
                if(result == null)
                {
                    result = new TransitionNode(fromOption);
                }
                for(int index=0; index < list.size(); index++)
                {
                    Transition t = (Transition)list.get(index);
                    if(visitedTransitions == null)
                    {
                        visitedTransitions = new ArrayList();
                    }
                    if(visitedTransitions.contains(t))
                    {
                        continue;
                    }
                    visitedTransitions.add(t);
                    TransitionNode child = result.addNode(t);
                    getTransitionTree(user, issueType, attribute, t.getTo(), child, visitedTransitions);
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private List getAvailableOptions(IssueType issueType, Attribute attribute, Module module, boolean activeOnly) throws ScarabException
    {
        List availableOptions;
        try 
        {
            availableOptions = module.getOptionTree(attribute,issueType,activeOnly);
        } catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
        return availableOptions;
    }
              
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
public static Workflow getInstance() throws ScarabException
    {
        Workflow wf = null;
        String className = null;
        try
        {
            if (getForceUseDefault())
            {
                wf = (Workflow) DefaultWorkflow.class.newInstance();
            }
            else
            {
                List classNames = Turbine.getConfiguration()
                    .getList("scarab.workflow.classname");
                if (classNames.size() > 0)
                {
                    className = (String) classNames.get(0);
                }
    
                Class wfClass = (className != null ? Class.forName(className) :
                                 DefaultWorkflow.class);
                wf = (Workflow) wfClass.newInstance();
            }
        }
        catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
        catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
        catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
        return wf;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
void doHandleDependencies()
        throws ScarabException, TorqueException
    {
        LOG.debug("Number of dependencies found: " + allDependencies.size());
        for (Iterator itr = allDependencies.iterator(); itr.hasNext();)
        {
            final Object[] data = (Object[])itr.next();
            final ActivitySet activitySetOM = (ActivitySet) data[0];
            final XmlActivity activity = (XmlActivity) data[1];
            

            final Dependency dependency = activity.getDependency();
            final String child = (String)issueXMLMap.get(dependency.getChild());
            final String parent = (String)issueXMLMap.get(dependency.getParent());
            if (parent == null || child == null)
            {
                if(null != parent || null != child)
                {
                    // add a comment into the issue that informs of the dependency
                    final Issue issueOM = IssueManager.getIssueById(null == parent ? child : parent);
                    final Attachment attachmentOM = new Attachment();
                    attachmentOM.setName("comment");
                    attachmentOM.setTypeId(Attachment.COMMENT__PK);
                    attachmentOM.setMimeType("text/plain");
                    // TODO i18n this
                    final String text = "Dependency \"" 
                            + parent + " (originally " + dependency.getParent() + ") " + dependency.getType() + ' ' 
                            + child + " (originally " + dependency.getParent()
                        + ") \" was not imported due to " 
                        + (null == parent ? dependency.getParent() : dependency.getChild()) + " not being resolved";
                    attachmentOM.setData(text);                    
                    issueOM.addComment(attachmentOM, ScarabUserManager.getInstance("Administrator"));
                }
                
                LOG.debug("Could not find issues: parent: " + parent + " child: " + child);
                LOG.debug("----------------------------------------------------");
                continue;
            }
            LOG.debug("doHandleDependencies: " + dependency);
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                LOG.error("[TODO] update-same-db import type not yet implemented");
                // trick here is that dependencies don't have ids or unique keys to find the 
                //  correct existing instance against.
            }
            else
            {
                try
                {
                    final String type = dependency.getType();
                    final Depend newDependOM = DependManager.getInstance();
                    final Issue parentIssueOM = IssueManager.getIssueById(parent);
                    final Issue childIssueOM = IssueManager.getIssueById(child);
                    newDependOM.setDefaultModule(parentIssueOM.getModule());
                    newDependOM.setObservedId(parentIssueOM.getIssueId());
                    newDependOM.setObserverId(childIssueOM.getIssueId());
                    newDependOM.setDependType(type);
                    LOG.debug("Dep: " + type + " Parent: " + parent + " Child: " + child);
                    LOG.debug("XML Activity id: " + activity.getId());
                    if (activity.isAddDependency())
                    {
                        parentIssueOM
                          .doAddDependency(activitySetOM, newDependOM, childIssueOM, null);
                        LOG.debug("Added Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isDeleteDependency())
                    {
                        parentIssueOM
                          .doDeleteDependency(activitySetOM, newDependOM, null);
                        LOG.debug("Deleted Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isUpdateDependency())
                    {
                        final Depend oldDependOM = parentIssueOM.getDependency(childIssueOM);
                        if (oldDependOM == null)
                        {
                            throw new IllegalArgumentException ("Whoops! Could not find the original dependency!"); //EXCEPTION
                        }
                        // we definitely know we are doing an update here.
                        newDependOM.setDeleted(false);
                        parentIssueOM
                          .doChangeDependencyType(activitySetOM, oldDependOM, newDependOM, null);
                        LOG.debug("Updated Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("Old Type: " + oldDependOM.getDependType().getName() + " New type: " + newDependOM.getDependType().getName());
                        LOG.debug("----------------------------------------------------");
                    }
                }
                catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }                
            }
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
public void addIssue(final XmlIssue issue)
        throws ScarabException
    {
        LOG.debug("Module.addIssue(): " + issue.getId());
        try
        {
            if (inValidationMode)
            {
                importErrors.setParseContext((issue.hasModuleCode()
                    ?"":module.getCode()) + issue.getId());
                doIssueValidateEvent(getModule(), issue);
            }
            else
            {
                doIssueEvent(getModule(), issue);
            }
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
        catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
        finally
        {
            importErrors.setParseContext(null);
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueEvent(final XmlModule module, final XmlIssue issue)
        throws TorqueException,ScarabException,ParseException
    {
/////////////////////////////////////////////////////////////////////////////////  
        // Get me an issue
        Issue issueOM = null;
        final String issueID = (issue.hasModuleCode() ? "" : module.getCode()) + issue.getId();
        if (getImportTypeCode() == CREATE_SAME_DB || getImportTypeCode() == CREATE_DIFFERENT_DB)
        {
            // Check if the new issue nominates an ID and if the database does
            // not already contain an issue with that ID
            if (issue.getId() != null && IssueManager.getIssueById(issueID) == null)
            {
                // Create the new issue with the nominated ID
                issueOM = createNewIssue(module, issue, issue.getId());
            }
            else
            {
                // Crate the new issue with an automatically allocated ID
                issueOM = createNewIssue(module, issue, null);
            }
        }
        else if (getImportTypeCode() == UPDATE_SAME_DB) // nice to specify just for searching/refactoring
        {
            issueOM = IssueManager.getIssueById(issueID);
            
            if (issueOM == null)
            {
                issueOM = createNewIssue(module, issue, null);
            }
            else
            {
                LOG.debug("Found Issue in db: " + issueOM.getUniqueId());
            }
        }

/////////////////////////////////////////////////////////////////////////////////  

        // Loop over the XML activitySets
        final List activitySets = issue.getActivitySets();
        LOG.debug("-----------------------------------");
        LOG.debug("Number of ActivitySets in Issue: " + activitySets.size());
        for (Iterator itr = activitySets.iterator(); itr.hasNext();)
        {
            final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
            LOG.debug("Processing ActivitySet: " + activitySet.getId());

/////////////////////////////////////////////////////////////////////////////////  
            // Deal with the attachment for the activitySet
            final XmlAttachment activitySetAttachment = activitySet.getAttachment();
            Attachment activitySetAttachmentOM = null;
            if (activitySetAttachment != null)
            {
                if (getImportTypeCode() == UPDATE_SAME_DB)
                {
                    try
                    {
                        activitySetAttachmentOM = AttachmentManager
                            .getInstance(activitySetAttachment.getId());
                        LOG.debug("Found existing ActivitySet Attachment");
                    }
                    catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
                }
                else
                {
                    activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    LOG.debug("Created ActivitySet Attachment object");
                }
            }
            else
            {
                LOG.debug("OK- No Attachment in this ActivitySet");
            }

/////////////////////////////////////////////////////////////////////////////////  
            // Attempt to get the activitySet OM
            boolean alreadyCreated = false;
            ActivitySet activitySetOM = null;
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                try
                {
                    activitySetOM = ActivitySetManager.getInstance(activitySet.getId());
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in db: " + activitySetOM.getActivitySetId());
                }
                catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            }
            else
            {
                // first try to get the ActivitySet from the internal map
                if (activitySetIdMap.containsKey(activitySet.getId()))
                {
                    activitySetOM = ActivitySetManager.getInstance(
                        (String)activitySetIdMap.get(activitySet.getId()));
                    alreadyCreated = true;
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in map: " + activitySetOM.getActivitySetId());
                }
                else // it hasn't been encountered previously
                {
                    activitySetOM = ActivitySetManager.getInstance();
                    LOG.debug("Created new ActivitySet");
                }
            }

            final ScarabUser activitySetCreatedByOM = findUser(activitySet.getCreatedBy());
            
            if (LOG.isDebugEnabled())
            {
                LOG.debug("ActivitySet: " + activitySet.getId() + "; of type: " + activitySet.getType() + "; by: " + activitySet.getCreatedBy());
                LOG.debug("   alreadyCreated: " + alreadyCreated);
            }
            
            if (!alreadyCreated)
            {
                // Populate the ActivitySet
                // Get the ActivitySet type/createdby values (we know these are valid)
                final ActivitySetType ttOM = ActivitySetTypeManager.getInstance(activitySet.getType());
                activitySetOM.setActivitySetType(ttOM);
                if( activitySetCreatedByOM != null ){
                    activitySetOM.setCreatedBy(activitySetCreatedByOM.getUserId());
                }
                else
                {
                	// Anonymous user. better than nothing.
                	try {
						activitySetOM.setCreatedBy(ScarabUserManager.getAnonymousUser().getUserId());
					} catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                }
                activitySetOM.setCreatedDate(activitySet.getCreatedDate().getDate());
                if (activitySetAttachmentOM != null)
                {
                    activitySetAttachmentOM.save();
                    activitySetOM.setAttachment(activitySetAttachmentOM);
                }
                activitySetOM.save();
                if( activitySet.getId() != null){
                    // if id is valid, save for later re-use.
                    activitySetIdMap.put(activitySet.getId(), 
                                         activitySetOM.getPrimaryKey().toString());
                }
            }

            // Determine if this ActivitySet should be marked as the 
            // creation event
            final ActivitySet creationSet = issueOM.getActivitySetRelatedByCreatedTransId();
            if (ActivitySetTypePeer.CREATE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) 
               ||
               (ActivitySetTypePeer.MOVE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) && 
                        (creationSet == null || activitySetOM.getCreatedDate()
                         .before(creationSet.getCreatedDate()))) ) 
            {
                issueOM.setActivitySetRelatedByCreatedTransId(activitySetOM);
                issueOM.save();
            }

/////////////////////////////////////////////////////////////////////////////////  
// Deal with changing user attributes. this code needs to be in this *strange*
// location because we look at the entire activityset in order to determine
// that this is a change user activity set. of course in the future, it would
// be really nice to create an activityset/activiy type that more accurately 
// reflects what type of change this is. so that it is easier to case for. for
// now, we just look at some fingerprints to determine this information. -JSS

            if (activitySet.isChangeUserAttribute())
            {
                final List activities = activitySet.getActivities();
                final XmlActivity activityA = (XmlActivity)activities.get(0);
                final XmlActivity activityB = (XmlActivity)activities.get(1);
                
                final ScarabUser assigneeOM = findUser(activityA.getOldUser());
                final ScarabUser assignerOM = findUser(activityB.getNewUser());

                final Attribute oldAttributeOM = Attribute.getInstance(activityA.getAttribute());

                final AttributeValue oldAttValOM = issueOM.getUserAttributeValue(assigneeOM, oldAttributeOM);
                if (oldAttValOM == null)
                {
                    LOG.error("User '" + assigneeOM.getName() + "' was not previously '" + oldAttributeOM.getName() + "' to the issue!");
                }

                // Get the Attribute associated with the new Activity
                final Attribute newAttributeOM = Attribute.getInstance(activityB.getAttribute());

                issueOM.changeUserAttributeValue(activitySetOM,
                            assigneeOM, 
                            assignerOM, 
                            oldAttValOM,
                            newAttributeOM, null);
                LOG.debug("-------------Updated User AttributeValue------------");
                continue;
            }

/////////////////////////////////////////////////////////////////////////////////  

            // Deal with the activities in the activitySet
            final List activities = activitySet.getActivities();
            LOG.debug("Number of Activities in ActivitySet: " + activities.size());

            final LinkedMap avMap = issueOM.getModuleAttributeValuesMap();
            LOG.debug("Total Module Attribute Values: " + avMap.size());
            for (Iterator itrb = activities.iterator(); itrb.hasNext();)
            {
                final XmlActivity activity = (XmlActivity) itrb.next();
                LOG.debug("Looking at activity id: " + activity.getId());

                // Get the Attribute associated with the Activity
                final Attribute attributeOM = Attribute.getInstance(activity.getAttribute());

                // deal with the activity attachment (if there is one)
                final XmlAttachment activityAttachment = activity.getAttachment();
                Attachment activityAttachmentOM = null;
                if (activityAttachment != null)
                {
                    // look for an existing attachment in the activity
                    // the case is when we have a URL and we create it
                    // and then delete it, the attachment id is still the
                    // same so there is no reason to re-create the attachment
                    // again.
                    final String previousXmlId = activityAttachment.getId();
                    final String previousId = (String)attachmentIdMap.get(previousXmlId);
                    if (previousId == null) 
                    {
                        activityAttachmentOM = createAttachment(issueOM, activityAttachment);
                        activityAttachmentOM.save();
                        attachmentIdMap.put(previousXmlId, activityAttachmentOM.getPrimaryKey().toString());
                        
                        // Special case. After the Attachment object has been 
                        // saved, if the ReconcilePath == true, then assume 
                        // that the fileName is an absolute path to a file and
                        // copy it to the right directory
                        // structure under Scarab's path.
                        if (allowFileAttachments && activityAttachment.getReconcilePath())
                        {
                            try
                            {
                                activityAttachmentOM
                                    .copyFileFromTo(activityAttachment.getFilename(), 
                                                    activityAttachmentOM.getFullPath());
                            } 
                            catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            } 
                            catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                        }
                        LOG.debug("Created Activity Attachment object");
                    }
                    else 
                    {
                        activityAttachmentOM = AttachmentManager
                            .getInstance(previousId);
                        LOG.debug("Found existing Activity Attachment");
                    }
                }
                else
                {
                    LOG.debug("OK- No Attachment in this Activity");
                }

                // deal with null attributes (need to do this before we create the 
                // activity right below because this will create its own activity).
                if (attributeOM.equals(nullAttribute))
                {
                    // add any dependency activities to a list for later processing
                    if (isDependencyActivity(activity))
                    {
                        if (!isDuplicateDependency(activity))
                        {
                            final Object[] obj = {activitySetOM, activity, activityAttachmentOM};
                            allDependencies.add(obj);
                            dependActivitySetId.add(activity.getDependency());
                            LOG.debug("-------------Stored Dependency # " 
                                    + allDependencies.size() + '[' + activity.getDependency() + ']');
                            continue;
                        }
                    }
                    else
                    {
                        // create the activity record.
                        ActivityManager.createTextActivity(issueOM, nullAttribute, activitySetOM, 
                                    ActivityType.getActivityType(activity.getActivityType()), activity.getDescription(), activityAttachmentOM, 
                                    activity.getOldValue(), activity.getNewValue());
        
                        LOG.debug("-------------Saved Null Attribute-------------");
                        continue;
                    }
                }

                // create the activityOM
                createActivity(activity, module, 
                                            issueOM, attributeOM, activitySetOM);

                // check to see if this is a new activity or an update activity
                AttributeValue avalOM = null;
                for (Iterator moduleAttributeValueItr = avMap.mapIterator(); 
                     moduleAttributeValueItr.hasNext() && avalOM == null;)
                {
                    final AttributeValue testAvalOM = (AttributeValue)
                        avMap.get(moduleAttributeValueItr.next());
                    final Attribute avalAttributeOM = testAvalOM.getAttribute();

                    LOG.debug("Checking Attribute match: " + avalAttributeOM.getName() + 
                              " against: " + attributeOM.getName());
                    if (avalAttributeOM.equals(attributeOM))
                    {
                        avalOM = testAvalOM;
                    }
                }

                if (avalOM != null) 
                {
                    final Attribute avalAttributeOM = avalOM.getAttribute();
                    LOG.debug("Attributes match!");
                    AttributeValue avalOM2 = null;
                    if (!activity.isNewActivity())
                    {
                        LOG.debug("Activity is not new.");
                        avalOM2 = AttributeValue.getNewInstance(
                            avalAttributeOM.getAttributeId(), 
                            avalOM.getIssue());
                        avalOM2.setProperties(avalOM);
                    }

                    if (avalAttributeOM.isOptionAttribute())
                    {
                        LOG.debug("We have an Option Attribute: " + 
                                  avalAttributeOM.getName());
                        final AttributeOption newAttributeOptionOM = 
                                AttributeOptionManager.getInstance(
                                         attributeOM, activity.getNewOption(),
                                         issueOM.getModule(),
                                         issueOM.getIssueType());
                        if (activity.isNewActivity())
                        {
                            if (newAttributeOptionOM != null)
                            {
                                avalOM.setOptionId(newAttributeOptionOM.getOptionId());
                                avalOM.startActivitySet(activitySetOM);
                                avalOM.setAttribute(attributeOM);
                                avalOM.save();
                                LOG.debug("-------------Saved Attribute Value-------------");
                            }
                            else
                            {
                                LOG.warn("NewAttributeOptionOM is null for " +
                                         activity.getNewOption());
                            }
                        }
                        else if(newAttributeOptionOM != null)
                        {
                            avalOM2.setOptionId(newAttributeOptionOM.getOptionId());
                            final HashMap map = new HashMap();
                            map.put(avalOM.getAttributeId(), avalOM2);
                            issueOM.setAttributeValues(activitySetOM, map, null, activitySetCreatedByOM);
                            LOG.debug("-------------Saved Option Attribute Change-------------");
                        }
                    }
                    else if (avalAttributeOM.isUserAttribute())
                    {
                        LOG.debug("We have a User Attribute: " 
                                  + avalAttributeOM.getName());
                        if (activity.isNewActivity())
                        {
                            // Don't need to pass in the attachment because
                            // it is already in the activitySetOM.
                            // If we can't get an assignee new-user, then 
                            // use the activity set creator as assignee.
                            ScarabUser assigneeOM = findUser(activity.getNewUser());
                            assigneeOM = (assigneeOM != null)
                                ? assigneeOM: activitySetCreatedByOM;
                            if( assigneeOM != null ){
                                issueOM.assignUser(activitySetOM, 
                                    assigneeOM, null, avalAttributeOM, null);
                            }
                            LOG.debug("-------------Saved User Assign-------------");
                        }
                        else if (activity.isRemoveUserActivity())
                        {
                            // remove a user activity
                            final ScarabUser oldUserOM = findUser(activity.getOldUser());
                            // need to reset the aval because the current one
                            // is marked as new for some reason which causes an
                            // insert and that isn't the right behavior here 
                            // (we want an update)
                            avalOM = null;
                            for (Iterator i = issueOM.getAttributeValues(
                                 avalAttributeOM).iterator(); 
                                 i.hasNext() && avalOM == null;) 
                            {
                                final AttributeValue av = (AttributeValue)i.next();
                                if (oldUserOM.getUserId().equals(av.getUserId())) 
                                {
                                    avalOM = av;
                                }
                            }

                            if (avalOM == null) 
                            {
                                if (LOG.isDebugEnabled()) 
                                {
                                    LOG.debug("Could not find previous AttributeValue assigning " +
                                        (oldUserOM == null ? "NULL" : 
                                        oldUserOM.getUserName()) + 
                                        " to attribute " + 
                                              avalAttributeOM.getName());
                                }                                
                            }
                            else 
                            {
                                // don't need to pass in the attachment because
                                // it is already in the activitySetOM
                                issueOM.deleteUser(activitySetOM, oldUserOM, 
                                    activitySetCreatedByOM, avalOM, null);
                                LOG.debug("-------------Saved User Remove-------------");
                            }
                        }
                    }
                    else if (avalAttributeOM.isTextAttribute() || avalAttributeOM.isIntegerAttribute())
                    {
                        LOG.debug("We have a Text Attribute: " + avalAttributeOM.getName());

                        avalOM.startActivitySet(activitySetOM);
                        avalOM.setAttribute(attributeOM);

                        if (activity.isNewActivity())
                        {
                            avalOM.setValue(activity.getNewValue());
                        }
                        else if (!activity.getNewValue()
                                .equals(avalOM.getValue()))
                        {
                            avalOM2.setValue(activity.getNewValue());
                            avalOM.setProperties(avalOM2);
                        }
                        
                        avalOM.save();
                        LOG.debug("-------------Saved Attribute Value-------------");
                    }
                }
                issueOM.save();
                LOG.debug("-------------Saved Issue-------------");
            }
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Module getModuleForIssue(final XmlModule module, final XmlIssue issue)
        throws TorqueException, ScarabException
    {
        
        if(issue.hasModuleCode() && !issue.getModuleCode().equals(module.getCode()) && !allowGlobalImport){
            throw new ScarabException(
                    new L10NKey("Lacking permission to cross-module import. Contact your administor. <localize me>"));
        }
        
        return issue.hasModuleCode()
                ? ModuleManager.getInstance(module.getDomain(),
                                            null,issue.getModuleCode())
                : ModuleManager.getInstance(module.getDomain(),
                                            module.getName(), module.getCode());
     }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected Collection runImport(final String filePath, 
            final Object input,
            final Module currentModule,
            final ImportType type)
        throws ScarabException
    {
        
        final String msg = "Importing issues from XML '" + filePath + '\'';
        LOG.debug(msg);
        try
        {
            // Disable workflow and set file attachment flag
            WorkflowFactory.setForceUseDefault(true);
            
            final Reader is = getScarabFormattedReader(input,type,currentModule);
            
            final BeanReader reader = createScarabIssuesBeanReader();
            validate(filePath, is, reader, currentModule);

            if (importErrors == null || importErrors.isEmpty())
            {
                // Reget the input stream.
                si = insert(filePath, getScarabFormattedReader(input,type,currentModule), reader);
            }
        }
        catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
        finally
        {
            // Re-enable workflow.
            WorkflowFactory.setForceUseDefault(false);
        }

        return importErrors;
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public List executeQuery(TextQuery textQuery) 
        throws Exception
    {
        String queryText = textQuery.toString();
        
        Query luceneQuery;
        try
        {
           luceneQuery = new QueryParser("", analyzer).parse(queryText);
        }
        catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }

        List issueIds = new ArrayList();
        IndexSearcher is = new IndexSearcher(indexDir); 
        try
        {
            Hits hits = is.search(luceneQuery);
            
            for(Iterator hi = hits.iterator(); hi.hasNext();)
            {
                Hit h = (Hit)hi.next();
                issueIds.add( Long.valueOf(h.get(ISSUE_ID)));
            }
        }
        finally
        {
            is.close();
        }        
        return issueIds;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addIssueIdRangeCriteria(Criteria crit)
        throws java.lang.Exception
    {
        Issue.FederatedId minFid = null;
        Issue.FederatedId maxFid = null;

        if(minId != null)
        {
            minFid = new Issue.FederatedId(minId);
        }
        if(maxId != null)
        {
            maxFid = new Issue.FederatedId(maxId);
        }
        setDefaults(minFid, maxFid);

        if ( minFid != null
          && maxFid != null
          && (   minFid.getCount() > maxFid.getCount() 
              || !StringUtils.equals(minFid.getPrefix(), maxFid.getPrefix())
              || !StringUtils.equals(minFid.getDomain(), maxFid.getDomain())))
        {
            throw new ScarabException(L10NKeySet.ExceptionIncompatibleIssueIds, minId, maxId);
        }
        else 
        {
            addIssueIdCrit(crit, minFid, Criteria.GREATER_EQUAL );
            addIssueIdCrit(crit, maxFid, Criteria.LESS_EQUAL );
        }        
    }
              
// in java/org/tigris/scarab/util/TurbineInitialization.java
public static void setUp(final String configDir, final String configFile)
        throws ScarabException,MalformedURLException,IOException
    {
        if (configDir == null || configFile == null)
        {
            System.err.println("config.dir System property was not defined");
            throw new ScarabException (new L10NKey("configDir or configFile was null")); // FIXME localise
        }

        // set this so that the proper substitution will happen in the
        // configFile
        System.getProperties().setProperty("configDir", configDir);

        initTurbine(configDir);
        
        final InputStream is = new File(configDir + configFile).toURL()
            .openStream();
        final Properties props = new Properties();
        try
        {
            props.load(is);
            // init Log4J
            PropertyConfigurator.configure(props);
        }
        catch (Exception e)
        {
            System.err.println("Can't read the properties file (" + 
                configDir + configFile + "). ");
        }
    }
              
// in java/org/tigris/scarab/util/Email.java
private static void sendEmailInLocale(EmailContext context, Module module,
                                          Object fromUser, Object replyToUser,
                                          List toAddresses, List ccAddresses,
                                          String template, Locale locale)
        throws Exception
    {
        log.debug("Sending email for locale=" + locale);

        // get reference to l10n tool, so we can alter the locale per email
        ScarabLocalizationTool l10n = new ScarabLocalizationTool();
        context.setLocalizationTool(l10n);
        l10n.init(locale);

        Email te = getEmail(context, module, fromUser, replyToUser, template);

        final String charSet = getCharset(locale);
        te.setCharset(charSet);
        context.put("charSet", new String(charSet));
        
        //te.addHeader("Content-Base: "");

        boolean atLeastOneTo = false;
        for (Iterator iTo = toAddresses.iterator(); iTo.hasNext();)
        {
            InternetAddress a = (InternetAddress) iTo.next();
            log.debug("Adding To: email[" + a.getAddress() + "], name["+a.getPersonal()+"]");
            te.addTo(a.getAddress(), a.getPersonal());
            atLeastOneTo = true;
        }
        for (Iterator iCC = ccAddresses.iterator(); iCC.hasNext();)
        {
            InternetAddress a = (InternetAddress) iCC.next();
            String email = a.getAddress();
            String name = a.getPersonal();

            
            // template email requires a To: user, it does seem possible
            // to send emails with only a CC: user, so not sure if this
            // is a bug to be fixed in TemplateEmail.  Might not be good
            // form anyway.  So if there are no To: users, upgrade CC's.
            if (atLeastOneTo)
            {
                log.debug("Adding CC: email[" + email + "], name["+name+"]");
                te.addCc(email, name);
            }
            else
            {
                log.debug("Adding to: email[" + email + "], name["+name+"]");
                te.addTo(email, name);
                // We've added one To: user and TemplateEmail should be
                // happy. No need to move all CC: into TO:
                atLeastOneTo = true;
            }
        }

        // Email threading -- applicable to issue related notifications
        Issue issue = null;
        String emailReferences = null;
        if(context.containsKey("issue"))
        {
            issue = (Issue) context.get("issue");
            emailReferences = null != issue.getEmailReferences()
                    ? issue.getEmailReferences()
                    : "";
            if(0 != emailReferences.length())
            {
                te.addHeader("References", emailReferences);
            }
        }

        String newEmailReference = null;
        try
        {
            log.debug("Sending email ...");
            newEmailReference = te.send();
            log.debug("... sent " + newEmailReference);
        }
        catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }

        if(null!=emailReferences && null!=newEmailReference)
        {
            // we record, within the varchar(2000) limit,
            // the MessageID of every mail sent if it's related to an issue change 
            // There must be an error in the length calculation, which sometimes causes
            // the issue.save() to throw an illegalLength exception. I tried to take care
            // of this here. [HD]

            if(emailReferences.length()>0) emailReferences += ' ';
            emailReferences += newEmailReference; 

            if(emailReferences.length() > 2000)
            {
                emailReferences = emailReferences.substring(
                        emailReferences.indexOf('<', emailReferences.length() - 2000));
            }
            try
            {
                issue.setEmailReferences(emailReferences);
                issue.save();
            }
            catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
        }
    }
36
              
// in java/org/tigris/scarab/om/MITList.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
              
// in java/org/tigris/scarab/om/MITList.java
catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
              
// in java/org/tigris/scarab/om/ROptionOption.java
catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
              
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
              
// in java/org/tigris/scarab/om/MITListItem.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
              
// in java/org/tigris/scarab/om/Issue.java
catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
              
// in java/org/tigris/scarab/om/ActivitySet.java
catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
              
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
              
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
              
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }
              
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
172
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Object getSessionAttribute(String key) throws ScarabException
    {
        HttpSession session = data.getSession();
        Object value;
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        value = session.getAttribute(key);
        return value;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean hasSessionAttribute(String key) throws ScarabException
    {
        HttpSession session = data.getSession();
        Object value;
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        value = session.getAttribute(key);
        return value != null;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean setSessionAttribute(String key, Object value) throws ScarabException
    {
        HttpSession session = data.getSession();
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        session.setAttribute(key,value);
        return true;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getTransitions(IssueType issueType,
            Attribute attribute) throws ScarabException
   {
        ScarabUser user = getCurrentUser();
        Workflow workflow = ScarabGlobalTool.getWorkflow();
        List result = workflow.getTransitions(user,issueType,attribute);
        return result;
   }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getTransitionMatrix(IssueType issueType,
            Attribute attribute) throws ScarabException
   {
        ScarabUser user = getCurrentUser();
        Workflow workflow = ScarabGlobalTool.getWorkflow();
        TransitionNode root = workflow.getTransitionTree(user,issueType,attribute);
        List result = root.createRows();
        return result;
   }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public static NotificationRule getNotificationRule(Integer moduleId, Integer userId, String activityCode) throws ScarabException
    {
        NotificationRule result = NotificationRuleManager.getNotificationRule(moduleId, userId, activityCode);
        return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public static Workflow getWorkflow() throws ScarabException
    {
        return WorkflowFactory.getInstance();
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setChainedValue(final AttributeValue  v)
        throws TorqueException, ScarabException
    {
        if (v == null)
        {
            this.chainedValue = null;
        }
        else 
        {        
            if (v.getAttributeId() == null && getAttributeId() != null) 
            {
                v.setAttributeId(getAttributeId());
            }
            else if (v.getAttribute() != null 
                     && !v.getAttribute().equals(getAttribute()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainAttributeValues,
                                          v.getAttributeId(),
                                          getAttributeId());
            }
            
            if (v.getIssueId() == null && getIssueId() != null) 
            {
                v.setIssueId(getIssueId());
            }
            else if (v.getIssue() != null 
                      && !v.getIssue().equals(getIssue()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainIssues,
                                          v.getIssueId(),
                                          getIssueId());
            }

            if (this.chainedValue == null) 
            {
                this.chainedValue = v;
            }
            else 
            {
                chainedValue.setChainedValue(v);
            }
            
            if (activitySet != null) 
            {
                v.startActivitySet(activitySet);
            }        
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void startActivitySet(ActivitySet activitySet)
        throws ScarabException, TorqueException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionCanNotStartActivitySet);
        }
        
        if (this.activitySet == null) 
        {
            this.activitySet = activitySet;
        }
        else
        {
            throw new ScarabException(L10NKeySet.ExceptionActivitySetInProgress);
        }
/*
This is wrong. It prevented the old/new value stuff from working properly!
If we have an existing issue and we change some attributes, then when the
history was created, the data was not valid in it for some reason. I'm not
quite sure why this was added. (JSS)

Leaving here so that John can remove or fix.

        oldOptionIdIsSet = false;
        oldValueIsSet = false;
        oldOptionId = null;
        oldValue = null;
*/

        // Check for previous active activities on this attribute 
        // If they exist, set old value for this activity
        List result = null;
        final Issue issue = getIssue();
        if (issue != null)
        {
            result = issue
                .getActivitiesWithNullEndDate(getAttribute());
        }
        if (result != null && result.size() > 0)
        {
            for (int i=0; i<result.size(); i++)
            {
                final Activity a = (Activity)result.get(i);
                oldOptionId = a.getNewOptionId();
                oldValue = a.getNewValue();
            }
        }
        if (chainedValue != null) 
        {
            chainedValue.startActivitySet(activitySet);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
private void checkActivitySet(LocalizationKey l10nKey)
        throws ScarabException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(l10nKey);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setOptionIds(final Integer[] ids)
        throws TorqueException, ScarabException
    {
        if (ids != null && ids.length > 0) 
        {
            setOptionId(ids[0]);
        }
        if (ids != null && ids.length > 1) 
        {
            for (int i=1; i<ids.length; i++) 
            {            
                final AttributeValue av = AttributeValue                
                    .getNewInstance(getAttributeId(), getIssue());
                setChainedValue(av);
                av.setOptionId(ids[i]);
            }
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public Integer[] getUserIds()
        throws ScarabException
    {
        throw new ScarabException(L10NKeySet.ExceptionGetUserIdsNotImplemented);
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setUserIds(final Integer[] ids)
        throws TorqueException, ScarabException
    {
        if (ids != null && ids.length > 0) 
        {
            setUserId(ids[0]);
        }
        if (ids != null && ids.length > 1) 
        {
            for (int i=1; i<ids.length; i++) 
            {            
                final AttributeValue av = AttributeValue                
                    .getNewInstance(getAttributeId(), getIssue());
                setChainedValue(av);
                av.setUserId(ids[i]);
            }
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public boolean isRequired()
       throws TorqueException, ScarabException
    {
        return getRModuleAttribute().getRequired();
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public RModuleAttribute getRModuleAttribute()
        throws TorqueException, ScarabException
    {
        final Issue issue = getIssue();
        RModuleAttribute rma = null;
        if (issue != null)
        {
            final Module module = issue.getModule();
            if (module != null)
            {
                rma = module.getRModuleAttribute(
                    getAttribute(), getIssue().getIssueType());
            }
            else
            {
                throw new ScarabException (L10NKeySet.ExceptionGeneral,
                        "Module is null: Please report this issue."); //EXCEPTION
            }
        }
        else
        {
            throw new ScarabException (L10NKeySet.ExceptionGeneral,
                    "Issue is null: Please report this issue."); //EXCEPTION
        }
        return rma;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonLeafRModuleOptions(final Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getLeafRModuleOptions(
                attribute,
                item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleOptionTree(Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getOptionTree(attribute, item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }  
        catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
    }
              
// in java/org/tigris/scarab/om/Query.java
public boolean saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped query, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        Exception exception=null; // temporary store a thrown exception

        if (getScopeId().equals(Scope.PERSONAL__PK) 
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        }
        else
        {
            setApproved(false);

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");

                final ScarabUser[] toUsers = module
                    .getUsers(ScarabSecurity.ITEM__APPROVE);

                if (Log.get().isDebugEnabled()) 
                {
                    if (toUsers == null || toUsers.length ==0) 
                    {
                        Log.get().debug("No users to approve query.");    
                    }
                    else 
                    {
                        Log.get().debug("Users to approve query: ");    
                        for (int i=0; i<toUsers.length; i++) 
                        {
                            Log.get().debug(toUsers[i].getEmail());
                        }  
                    }          
                }
                
                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewQueryRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx,
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null,
                        template);
                }
                catch (Exception e)
                {
                    exception = e;
                }
            }
        }
        if (getMITList() != null) 
        {
            getMITList().save();
            // it would be good if this updated our list id, but it doesn't
            // happen automatically so reset it.
            setMITList(getMITList());            
        }
        save();
        if(exception != null)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral, exception);
        }
        return true;
    }
              
// in java/org/tigris/scarab/om/Query.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/Query.java
public void delete(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module)
          || (user.getUserId().equals(getUserId()) 
             && getScopeId().equals(Scope.PERSONAL__PK)))
        {
            // Delete user-query maps.
            final List rqus = getRQueryUsers();
            for (int i=0; i<rqus.size(); i++)
            {
                final RQueryUser rqu = (RQueryUser)rqus.get(i);
                rqu.delete(user);
            }
            setDeleted(true);
            save();
            
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final ActivitySetType tt, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return getInstance(tt.getTypeId(), user, null);
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final ActivitySetType tt, 
            final ScarabUser user, 
            final Attachment attachment)
        throws TorqueException, ScarabException
    {
        return getInstance(tt.getTypeId(), user, attachment);
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
            final ScarabUser user)
        throws TorqueException,ScarabException
    {
        return getInstance(typeId, user, null);
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
                                          final ScarabUser user, 
                                          final Attachment attachment)
        throws TorqueException,ScarabException
    {
        if (attachment != null && attachment.getAttachmentId() == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNeedToSaveAttachement);
        }
        final ActivitySet activitySet = new ActivitySet();
        activitySet.setTypeId(typeId);
        activitySet.setCreatedBy(user.getUserId());
        activitySet.setCreatedDate(new Date());
        if (attachment != null && 
            attachment.getData() != null &&
            attachment.getData().length() > 0)
        {
            activitySet.setAttachment(attachment);
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void delete()
         throws TorqueException, ScarabException
    {                
         delete(false);
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
protected void delete(final boolean overrideLock)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        final IssueType issueType = IssueTypeManager
           .getInstance(getIssueTypeId(), false);
        if (issueType.getLocked() && !overrideLock)
        { 
            throw new ScarabException(L10NKeySet.CannotDeleteAttributeFromLockedIssueType);
        }            
        else
        {
            final Criteria c = new Criteria()
                .add(RModuleAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleAttributePeer.doDelete(c);
            final Attribute attr = getAttribute();
            String attributeType = null;
            attributeType = (attr.isUserAttribute() ? Module.USER : Module.NON_USER);
            module.getRModuleAttributes(getIssueType(), false, attributeType)
                                        .remove(this);
            WorkflowFactory.getInstance().deleteWorkflowsForAttribute(
                                          attr, module, getIssueType());

            // delete module-user-attribute mappings
            final Criteria crit = new Criteria()
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attr.getAttributeId())
                .add(RModuleUserAttributePeer.MODULE_ID, 
                     getModuleId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                     getIssueTypeId());
            RModuleUserAttributePeer.doDelete(crit);

            // delete module-option mappings
            if (attr.isOptionAttribute())
            {
                final List optionList = module.getRModuleOptions(attr, 
                                  IssueTypePeer.retrieveByPK(getIssueTypeId()), 
                                  false);
                if (optionList != null && !optionList.isEmpty())
                {
                    final List optionIdList =
                        new ArrayList(optionList.size());
                    for (int i = 0; i < optionList.size(); i++)
                    { 
                        optionIdList.add(((RModuleOption)
                                          optionList.get(i))
                                         .getOptionId());
                    }
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID, getModuleId())
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,
                             getIssueTypeId())
                        .addIn(RModuleOptionPeer.OPTION_ID, optionIdList);
                    RModuleOptionPeer.doDelete(c2);
                }
            }
        }

        RModuleAttributeManager.removeInstanceFromCache(this);
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public void delete()
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

            final IssueType issueType = IssueTypeManager
               .getInstance(getIssueTypeId(), false);
            if (issueType.getLocked())
            { 
                throw new ScarabException(L10NKeySet.ExceptionDeleteOptionFromLockedIssueType);
            }            
            else
            {
                Integer moduleId    = getModuleId();
                Integer issueTypeId = getIssueTypeId();
                Integer optionId    = getOptionId();
                int orderNumber     = getOrder();

                // delete the option
                final Criteria c = new Criteria()
                    .add(RModuleOptionPeer.MODULE_ID, moduleId)
                    .add(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId)
                    .add(RModuleOptionPeer.OPTION_ID, optionId);
                RModuleOptionPeer.doDelete(c);
                
                // delete associated workflow
                WorkflowFactory.getInstance().deleteWorkflowsForOption(getAttributeOption(), 
                                             module, issueType);

                // ======================================================
                // Correct the ordering of the remaining options
                // ======================================================

                // first retrieve the list of still available option ids
                final List optIds = new ArrayList();
                final List rmos = module.getRModuleOptions(getAttributeOption().getAttribute(), issueType, false);
                for (int i=0; i<rmos.size();i++)
                {
                    final RModuleOption rmo = (RModuleOption)rmos.get(i);
                    optIds.add(rmo.getOptionId());
                }
               
                // Need to perform the correction only if the deleted option had follow up options
                if(optIds.size() > 0)
                {
                    // update the list
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID,       moduleId)
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,   issueTypeId)
                        .addIn(RModuleOptionPeer.OPTION_ID,     optIds)
                        .add(RModuleOptionPeer.PREFERRED_ORDER, orderNumber, Criteria.GREATER_THAN);
                    final List adjustRmos = RModuleOptionPeer.doSelect(c2);
                    for (int j=0; j<adjustRmos.size();j++)
                    {
                        final RModuleOption rmo = (RModuleOption)adjustRmos.get(j);
                        //rmos.remove(rmo);
                        rmo.setOrder(rmo.getOrder() -1);
                        rmo.save();
                        //rmos.add(rmo);
                    }
                }
            }
            // notify module cache of this change
            ((ModuleManager)Torque.getManager(ModuleManager.MANAGED_CLASS))
                .refreshedObject(this);
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getInstanceByEmail(final String email) 
        throws TorqueException,ScarabException
    {
        return getManager().getInstanceByEmailImpl(email);
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected ScarabUser getInstanceByEmailImpl(final String email) 
        throws TorqueException,ScarabException
    {
        ScarabUser user = null;
        if (email != null) 
        {
            final Criteria crit = new Criteria();
            crit.add(ScarabUserImplPeer.EMAIL, email);
            final List users = ScarabUserImplPeer.doSelect(crit);
            if (users.size() == 1) 
            {
                user = (ScarabUser)users.get(0);
            }
            else if (users.size() > 1) 
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateUsername); 
            }
        }
        return user;
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public void save()
        throws TorqueException, ScarabException
    {
        AttributeOption ao = null;
        ROptionOption roo = null;

        final Attribute tmpAttr = AttributeManager.getInstance(getAttributeId());
        
        // if it is new, it won't already have an optionId
        if (getOptionId() == null)
        {
            // if it is new, check for duplicates.
            final AttributeOption duplicate = 
                AttributeOptionManager.getInstance(tmpAttr, getName().trim());
            final AttributeOption parent = 
                AttributeOptionManager.getInstance(getParentId());
            if (duplicate != null)
            {
                throw new ScarabException (new L10NKey("CannotCreateDuplicateOption")); //EXCEPTION
            }
            else if (parent.getDeleted())
            {
                throw new ScarabException (new L10NKey("CannotCreateChild")); //EXCEPTION
            }
        }

        // if getOptionId() is null, then it will just create a new instance
        final Integer optionId = getOptionId();
        if (optionId == null)
        {
            ao = AttributeOptionManager.getInstance();
        } 
        else
        {
            ao = AttributeOptionManager.getInstance(getOptionId());
        }

        
        ao.setName(getName());
        ao.setDeleted(getDeleted());
        ao.setAttribute(tmpAttr);
        ao.setStyle(getStyle());
        ao.save();

        // clean out the caches for the AO
        tmpAttr.doRemoveCaches();

        // now set our option id from the saved AO
        this.setOptionId(ao.getOptionId());

        // now create the ROO mapping
        try
        {
            // look for a cached ROptionOption
            roo = ROptionOption.getInstance(getParentId(), getOptionId());
        }
        catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
        roo.setPreferredOrder(getPreferredOrder());
        roo.setWeight(getWeight());
        roo.setRelationshipId(OptionRelationship.PARENT_CHILD);
        roo.save();
    }
              
// in java/org/tigris/scarab/om/ROptionOption.java
public static ROptionOption getInstance(final Integer parent, final Integer child)
        throws ScarabException
    {
    	ROptionOption option = null;
    	try
        {
    	    final Criteria crit = new Criteria();
            crit.add (ROptionOptionPeer.OPTION1_ID, parent);
            crit.add (ROptionOptionPeer.OPTION2_ID, child);
            option = (ROptionOption) (ROptionOptionPeer.doSelect(crit)).get(0);
        }
        catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
        return option;
    }
              
// in java/org/tigris/scarab/om/ActivitySetType.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException, ScarabException
    {
        return ActivitySetTypeManager.getInstance(activitySetTypeName);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public IssueType getTemplateIssueType()
        throws TorqueException, ScarabException
    {
        if (templateIssueType == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.PARENT_ID, getIssueTypeId());
            final List results = IssueTypePeer.doSelect(crit);
            if (results.isEmpty())
            {
                throw new ScarabException(L10NKeySet.ExceptionTemplateTypeForIssueType);
            }
            else
            {
                templateIssueType = (IssueType)results.get(0);
            }
        }
        return templateIssueType;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public Integer getTemplateId()
        throws TorqueException, ScarabException
    {
        return getTemplateIssueType().getIssueTypeId();
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public static IssueType getInstance(final String issueTypeName)
        throws TorqueException,ScarabException
    {
        IssueType result = null;
        Object obj = ScarabCache.get(ISSUE_TYPE, GET_INSTANCE, issueTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.NAME, issueTypeName);
            final List issueTypes = IssueTypePeer.doSelect(crit);
            if(issueTypes == null || issueTypes.size() == 0)
            {
                throw new ScarabException(L10NKeySet.ExceptionInvalidIssueType,
                                          issueTypeName);
            }
            result = (IssueType)issueTypes.get(0);
            ScarabCache.put(result, ISSUE_TYPE, GET_INSTANCE, issueTypeName);
        }
        else 
        {
            result = (IssueType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public IssueType copyIssueType()
        throws TorqueException, ScarabException
    {
        final IssueType newIssueType = new IssueType();
        newIssueType.setName(getName() + " (copy)");
        newIssueType.setDescription(getDescription());
        newIssueType.setParentId(ScarabConstants.INTEGER_0);
        newIssueType.save();
        final Integer newId = newIssueType.getIssueTypeId();

        // Copy template type
        final IssueType template = IssueTypePeer
              .retrieveByPK(getTemplateId());
        final IssueType newTemplate = new IssueType();
        newTemplate.setName(template.getName());
        newTemplate.setParentId(newId);
        newTemplate.save();

        // Copy user attributes
        final List userRIAs = getRIssueTypeAttributes(false, USER);
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            final RIssueTypeAttribute newUserRia = userRia.copyRia();
            newUserRia.setIssueTypeId(newId);
            newUserRia.save();
        }

        // Copy attribute groups
        final List attrGroups = getAttributeGroups(false);
        for (int i = 0; i<attrGroups.size(); i++)
        {
            final AttributeGroup group = (AttributeGroup)attrGroups.get(i);
            final AttributeGroup newGroup = group.copyGroup();
            newGroup.setIssueTypeId(newId);
            newGroup.save();

            // add attributes
            final List attrs = group.getAttributes();
            if (attrs != null)
            {
                for (int j=0; j<attrs.size(); j++)
                {
                    // save attribute-attribute group maps
                    final Attribute attr = (Attribute)attrs.get(j);
                    final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                    final RAttributeAttributeGroup newRaag = new RAttributeAttributeGroup();
                    newRaag.setAttributeId(raag.getAttributeId());
                    newRaag.setOrder(raag.getOrder());
                    newRaag.setGroupId(newGroup.getAttributeGroupId());
                    newRaag.save();

                    // save attribute-issueType maps
                    final RIssueTypeAttribute ria = getRIssueTypeAttribute(attr);
                    final RIssueTypeAttribute newRia = ria.copyRia();
                    newRia.setIssueTypeId(newId);
                    newRia.save();

                    // save options
                    final List rios = getRIssueTypeOptions(attr, false);
                    if (rios != null)
                    {
                        for (int k=0; k<rios.size(); k++)
                        {
                            final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                            final RIssueTypeOption newRio = rio.copyRio();
                            newRio.setIssueTypeId(newId);
                            newRio.save();
                        }
                    }
                }
            }
        }

        // add workflow 
        WorkflowFactory.getInstance().copyIssueTypeWorkflows(this, newIssueType);

        return newIssueType;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public void deleteModuleMappings(final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                 getIssueTypeId());
        final List rmits = RModuleIssueTypePeer.doSelect(crit);
        for (int i=0; i<rmits.size(); i++)
        {
            final RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
            rmit.delete(user);
        }
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public boolean canCreateIssueInScope(ScarabUser user, Module module) throws TorqueException, ScarabException
    {
        //[HD first check, if user has IssueCreate permission in this module
        boolean isPermissionGranted = user.hasPermission(ScarabSecurity.ISSUE__ENTER, module);
        
        if(isPermissionGranted)
        {
            List requiredAttributes = getRequiredAttributes(module);
            Iterator iter = requiredAttributes.iterator();
            while(iter.hasNext())
            {
                Attribute attribute = (Attribute)iter.next();
                Workflow workflow = WorkflowFactory.getInstance();
                if(attribute.isOptionAttribute())
                {
                    boolean canDoPartial = workflow.canMakeTransitionsFrom(user, this, attribute, null);
                    if(!canDoPartial)
                    {
                        isPermissionGranted = false;
                        break;
                    }
                }
            }
        }
        return isPermissionGranted;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public boolean canCreateAttributeInScope(ScarabUser user, Module module, Attribute attribute) throws TorqueException, ScarabException
    {
        boolean result = true;
        Workflow workflow = WorkflowFactory.getInstance();
        if(attribute.isOptionAttribute())
        {
            result = workflow.canMakeTransitionsFrom(user, this, attribute, null);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user)
        throws ScarabException
    {
        int count = 0;
        try 
        {
            IssueSearch is = IssueSearchFactory.INSTANCE
                .getInstance(getModule(), getIssueType(), user);
            count = is.getIssueCount();
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
        return count;
    }
              
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user, AttributeOption attributeOption)
        throws TorqueException, ScarabException, DataSetException
    {
        Criteria crit = new Criteria();

        Integer attributeId = attributeOption.getAttributeId();
        Integer optionId    = attributeOption.getOptionId();

        crit.add(AttributeValuePeer.ATTRIBUTE_ID, attributeId);
        crit.add(AttributeValuePeer.OPTION_ID,optionId);
        crit.add(AttributeValuePeer.DELETED,0);
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.TYPE_ID,this.getIssueTypeId());
        crit.add(IssuePeer.MOVED, 0);
        crit.add(IssuePeer.DELETED, 0);
        crit.addJoin(AttributeValuePeer.ISSUE_ID, IssuePeer.ISSUE_ID);

        int count = AttributeValuePeer.count(crit);
        return count;
    }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(NotificationStatus notif) throws ScarabException
    {
        NotificationRule rule = null;
        try
        {
            Long issueId = notif.getIssueId();
            Issue issue = IssueManager.getInstance(issueId);
            Integer moduleId = issue.getModuleId();
            Integer userId = notif.getReceiverId();
            ActivityType activityType = notif.getActivityType();
            rule = getNotificationRule(moduleId, userId, activityType.getCode());
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
        return rule;
    }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(Integer moduleId, Integer userId, String activityType) throws ScarabException
    {
        NotificationRule rule = null;
        
        int managerId = NotificationManagerFactory.getInstance().getManagerId();
        Criteria crit = new Criteria();
        crit.add(NotificationRulePeer.USER_ID, userId);
        crit.add(NotificationRulePeer.MODULE_ID, moduleId);
        crit.add(NotificationRulePeer.ACTIVITY_TYPE, activityType);
        crit.add(NotificationRulePeer.MANAGER_ID, managerId);
                
        try
        {
            List<NotificationRule> ruleSet = (List<NotificationRule>)NotificationRulePeer.doSelect(crit);     
            if(ruleSet == null || ruleSet.size()==0)
            {

                rule = NotificationRule.createDefaultRule( 
                       moduleId, 
                       userId,
                       managerId,
                       activityType);
            }
            else if (ruleSet.size() > 1)
            {
                String msg = "Database inxonsistency:"
                           + " Expected at most one key matching (user_id,module_id,activity_type,manager_id) = "
                           + ")" + userId + "," + moduleId + "," + activityType + "," + managerId + ")";
                throw new TorqueException(msg,new Throwable());
            }
            else
            {
                rule = ruleSet.get(0);
            }
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }

        return rule;
    }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static boolean isNotificationEnabledFor(ScarabUser user, Issue issue, boolean isSelf, String activityType, ActivitySet activitySet) throws ScarabException, TorqueException
    {
        Integer userId   = user.getUserId();
        Module module    = issue.getModule();
        Integer moduleId = module.getModuleId();
        
        NotificationRule rule = getNotificationRule(moduleId, userId, activityType);
        boolean isEnabled;
        if(isSelf)
        {
            isEnabled = rule.getSendSelf();
        }
        else
        {
            if(issue.isSealed() && !activitySet.hasTransitionSealed())
            {
                isEnabled = false; // Do not send notifications to other users when Issue is "closed"
            }
            else
            {
                isEnabled = rule.getFilterState();
            }
        }
        
        if(isEnabled)
        {
            Notification notification = new Notification(user, issue);
            isEnabled = notification.sendConditionsMatch();
        }
        return isEnabled;
    }
              
// in java/org/tigris/scarab/om/RIssueTypeOption.java
public void delete(final ScarabUser user, final Module module)
         throws TorqueException, ScarabException
    {                
        if (user.hasPermission(ScarabSecurity.DOMAIN__EDIT, module))
        {
            final List rios = getIssueType().getRIssueTypeOptions(
                                      getAttributeOption().getAttribute(), false);
            final Criteria c = new Criteria()
                .add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
            RIssueTypeOptionPeer.doDelete(c);
            rios.remove(this);
            if (rios.size() > 0)
            {
                // Correct the ordering of the remaining options
                final ArrayList optIds = new ArrayList();
                for (int i=0; i<rios.size();i++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)rios.get(i);
                    optIds.add(rio.getOptionId());
                }
                final Criteria c2 = new Criteria()
                    .addIn(RIssueTypeOptionPeer.OPTION_ID, optIds)
                    .add(RIssueTypeOptionPeer.PREFERRED_ORDER, getOrder(), 
                         Criteria.GREATER_THAN);
                final List adjustRios = RIssueTypeOptionPeer.doSelect(c2);
                for (int j=0; j<adjustRios.size();j++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)adjustRios.get(j);
                    rio.setOrder(rio.getOrder() -1);
                    rio.save();
                }
            }
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public ScarabUser[] getEligibleUsers(Attribute attribute)
        throws TorqueException,ScarabException
    {
        ScarabUser[] users = null;
        if (attribute.isUserAttribute()) 
        {
            String permission = attribute.getPermission();
            if (permission == null) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionNoAttributePermission,
                        attribute.getName());
            }
            else 
            {
                users = getUsers(permission);
            }
        }
        return users;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getSavedReports(final ScarabUser user)
        throws TorqueException,ScarabException
    {
        List reports = null;
        final Object obj = ScarabCache.get(this, GET_SAVED_REPORTS, user); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria()
                .add(ReportPeer.DELETED, 0);
            final Criteria.Criterion cc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.MODULE__PK, Criteria.EQUAL);
            cc.and(crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL));
            final Criteria.Criterion personalcc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.PERSONAL__PK, Criteria.EQUAL);
            personalcc.and(crit.getNewCriterion(
                ReportPeer.USER_ID, user.getUserId(), Criteria.EQUAL));
            final Criteria.Criterion personalmodulecc = crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL);
            personalmodulecc.or(crit.getNewCriterion(
                ReportPeer.MODULE_ID, null, Criteria.EQUAL));
            personalcc.and(personalmodulecc);
            cc.or(personalcc);
            crit.add(cc);
            crit.addAscendingOrderByColumn(ReportPeer.SCOPE_ID);
            final List torqueReports = ReportPeer.doSelect(crit);      
            // create ReportBridge's from torque Reports.
            if (!torqueReports.isEmpty()) 
            {
                reports = new ArrayList(torqueReports.size());
                for (Iterator i = torqueReports.iterator(); i.hasNext();) 
                {
                    final Report torqueReport = (Report)i.next();
                    try 
                    {
                        reports.add( new ReportBridge(torqueReport) );
                    }
                    catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }     
                    catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
                }
            }
            else 
            {
                reports = Collections.EMPTY_LIST;
            }

            ScarabCache.put(reports, this, GET_SAVED_REPORTS, user);
        }
        else 
        {
            reports = (List)obj;
        }
        return reports;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleAttribute addRModuleAttribute(final IssueType issueType,
                                                final Attribute attribute)
        throws TorqueException, ScarabException
    {
        String attributeType = null;
        attributeType = (attribute.isUserAttribute() ? USER : NON_USER);

        final RModuleAttribute rma = new RModuleAttribute();
        rma.setModuleId(getModuleId());
        rma.setIssueTypeId(issueType.getIssueTypeId());
        rma.setAttributeId(attribute.getAttributeId());
        rma.setOrder(getLastAttribute(issueType, attributeType) + 1);
        rma.setConditionsArray(attribute.getConditionsArray(), attribute.getConditionOperator());
        rma.save();
        getRModuleAttributes(issueType, false, attributeType).add(rma);

        // Add to template type
        final IssueType templateType = IssueTypeManager
            .getInstance(issueType.getTemplateId(), false);
        final RModuleAttribute rma2 = new RModuleAttribute();
        rma2.setModuleId(getModuleId());
        rma2.setIssueTypeId(templateType.getIssueTypeId());
        rma2.setAttributeId(attribute.getAttributeId());
        rma2.setOrder(getLastAttribute(templateType, attributeType) + 1);
        rma2.save();
        return rma;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAllAttributeOptions(Integer attributeId)
            throws TorqueException, ScarabException
    {
        List result;
        if (attributeId == null)
        {
            this.getLog().warn(
                    "No attribute specified while fetching attribute options.");
            result = Collections.EMPTY_LIST;
        } else
        {
            int id = attributeId.intValue();
            Attribute attribute = Attribute.getInstance(id);
            if (attribute == null)
            {
                this.getLog().warn(
                        "No options found for Attribute [" + attributeId + "]");
                // L10NMessage msg = new
                // L10NMessage(L10NKeySet.AttributeNotInSession,""+attributeId);
                // throw new ScarabException(msg);
                result = Collections.EMPTY_LIST;
            } else
            {
                // Integer attributeId = attribute.getAttributeId();

                Criteria crit = new Criteria();
                crit.add(AttributeOptionPeer.ATTRIBUTE_ID, attributeId);
                crit.add(AttributeOptionPeer.DELETED, false);
                result = AttributeOptionPeer.doSelect(crit);
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addAttributeOption(final IssueType issueType, 
            final AttributeOption option)
        throws TorqueException, ScarabException
    {
        final RModuleOption rmo = addRModuleOption(issueType, option);
        rmo.save();
        shiftAttributeOption(option.getAttribute(), issueType, rmo.getOrder());

        // add module-attributeoption mappings to template type
        final IssueType templateType = IssueTypeManager
                 .getInstance(issueType.getTemplateId());
        final RModuleOption rmo2 = addRModuleOption(templateType, option);
        rmo2.save();
        //FIXME: is it useful to shift options for the templateType?
        //shiftAttributeOption(option.getAttribute(), templateType, rmo.getOrder());
        
        //if the cache is not cleared, when two options are added at the same time, 
        //getLastAttributeOption does not take into account the newest active options.
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void setRmaBasedOnIssueType(final RIssueTypeAttribute ria)
        throws TorqueException, ScarabException
    {
        final RModuleAttribute rma = new RModuleAttribute(); 
        rma.setModuleId(getModuleId());
        rma.setIssueTypeId(ria.getIssueTypeId());
        rma.setAttributeId(ria.getAttributeId());
        rma.setActive(ria.getActive());
        rma.setRequired(ria.getRequired());
        rma.setOrder(ria.getOrder());
        rma.setQuickSearch(ria.getQuickSearch());
        rma.setDefaultTextFlag(ria.getDefaultTextFlag());
        rma.save();
        final RModuleAttribute rma2 = rma.copy();
        rma2.setModuleId(getModuleId());
        rma2.setIssueTypeId(ria.getIssueType().getTemplateId());
        rma2.setAttributeId(ria.getAttributeId());
        rma2.setActive(ria.getActive());
        rma2.setRequired(ria.getRequired());
        rma2.setOrder(ria.getOrder());
        rma2.setQuickSearch(ria.getQuickSearch());
        rma2.setDefaultTextFlag(ria.getDefaultTextFlag());
        rma2.save();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void setRmoBasedOnIssueType(final RIssueTypeOption rio)
        throws TorqueException, ScarabException
    {
        final RModuleOption rmo = new RModuleOption(); 
        rmo.setModuleId(getModuleId());
        rmo.setIssueTypeId(rio.getIssueTypeId());
        rmo.setOptionId(rio.getOptionId());
        rmo.setActive(rio.getActive());
        rmo.setOrder(rio.getOrder());
        rmo.setWeight(rio.getWeight());
        rmo.save();
        final RModuleOption rmo2 = rmo.copy();
        rmo2.setModuleId(getModuleId());
        rmo2.setIssueTypeId(rio.getIssueType().getTemplateId());
        rmo2.setOptionId(rio.getOptionId());
        rmo2.setActive(rio.getActive());
        rmo2.setOrder(rio.getOrder());
        rmo2.setWeight(rio.getWeight());
        rmo2.save();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getTemplateTypes()
        throws TorqueException, ScarabException
    {
        List templateTypes = new ArrayList();
        final Object obj = ScarabCache.get(this, GET_TEMPLATE_TYPES); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                     IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.DELETED, 0);
            final List rmits = RModuleIssueTypePeer.doSelect(crit);
            for (int i=0; i<rmits.size(); i++)
            {
                final RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
                final IssueType templateType = rmit.getIssueType().getTemplateIssueType();
                templateTypes.add(templateType);
            }
            ScarabCache.put(templateTypes, this, GET_TEMPLATE_TYPES);
        }
        else 
        {
            templateTypes = (List)obj;
        }
        return templateTypes;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void setInitialAttributesAndIssueTypes()
        throws TorqueException, DataSetException, ScarabException
    {
        isInitializing = true;
        ValidationException ve = null;
        try
        {
        // Add defaults for issue types and attributes 
        // from parent module
        final Module parentModule = ModuleManager.getInstance(getParentId());
        if(parentModule != null && parentModule.getModuleId().intValue() != 0){
        	inheritFromParent(parentModule);  //don't inherit anything from global data/module
        }
        
        final List defaultIssueTypes = IssueTypePeer.getDefaultIssueTypes();
        for (int i=0; i< defaultIssueTypes.size(); i++)
        {
            final IssueType defaultIssueType = (IssueType)defaultIssueTypes.get(i);
            if (!includesIssueType(defaultIssueType))
            {
                try
                {
                    addIssueType(defaultIssueType);
                }
                catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
            }
        }
        }
        finally
        {
            isInitializing = false;
        }
        if (ve != null) 
        {
            throw ve;
        }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void inheritFromParent(final Module parentModule)
        throws TorqueException, ScarabException
    {
        final Integer newModuleId = getModuleId();
        AttributeGroup ag1;
        AttributeGroup ag2;
        RModuleAttribute rma1 = null;
        RModuleAttribute rma2 = null;
            
        //save RModuleAttributes for template types.
        final List templateTypes = parentModule.getTemplateTypes();
        for (int i=0; i<templateTypes.size(); i++)
        {
            final IssueType it = (IssueType)templateTypes.get(i);
            final List rmas = parentModule.getRModuleAttributes(it);
            for (int j=0; j<rmas.size(); j++)
            {
                rma1 = (RModuleAttribute)rmas.get(j);
                rma2 = rma1.copy();
                rma2.setModuleId(newModuleId);
                rma2.setAttributeId(rma1.getAttributeId());
                rma2.setIssueTypeId(rma1.getIssueTypeId());
                getLog().debug("[ASM] Saving rma for new template type: " + 
                                    rma2.getModuleId()
                                    + "-" + rma2.getIssueTypeId() + "-" +
                                    rma2.getAttributeId());
                rma2.save();
            }
        }

        // set module-issue type mappings
        final List rmits = parentModule.getRModuleIssueTypes();
        for (int i=0; i<rmits.size(); i++)
        {
            final RModuleIssueType rmit1 = (RModuleIssueType)rmits.get(i);
            final RModuleIssueType rmit2 = rmit1.copy();
            rmit2.setModuleId(newModuleId);
            rmit2.save();
            final IssueType issueType = rmit1.getIssueType();

            // set attribute group defaults
            final List attributeGroups = issueType
                .getAttributeGroups(parentModule, true);
            for (int j=0; j<attributeGroups.size(); j++)
            {
                ag1 = (AttributeGroup)attributeGroups.get(j);
                ag2 = ag1.copy();
                ag2.setModuleId(newModuleId);
                ag2.getRAttributeAttributeGroups().clear();    // are saved later
                ag2.save();

                final List attributes = ag1.getAttributes();
                for (int k=0; k<attributes.size(); k++)
                {
                    final Attribute attribute = (Attribute)attributes.get(k);

                    // set attribute-attribute group defaults
                    final RAttributeAttributeGroup raag1 = ag1
                        .getRAttributeAttributeGroup(attribute);
                    final RAttributeAttributeGroup raag2 = raag1.copy();
                    raag2.setGroupId(ag2.getAttributeGroupId());
                    raag2.setAttributeId(raag1.getAttributeId());
                    raag2.setOrder(raag1.getOrder());
                    raag2.save();
                }
            }

            // set module-attribute defaults
            final List rmas = parentModule.getRModuleAttributes(issueType);
            if (rmas != null && rmas.size() >0)
            {
                for (int j=0; j<rmas.size(); j++)
                {
                    rma1 = (RModuleAttribute)rmas.get(j);
                    rma2 = rma1.copy();
                    rma2.setModuleId(newModuleId);
                    rma2.setAttributeId(rma1.getAttributeId());
                    rma2.setIssueTypeId(rma1.getIssueTypeId());
                    rma2.save();

                    // set module-option mappings
                    final Attribute attribute = rma1.getAttribute();
                    if (attribute.isOptionAttribute())
                    {
                        final List rmos = parentModule.getRModuleOptions(attribute,
                                                                   issueType);
                        if (rmos != null && rmos.size() > 0)
                        {
                            for (int m=0; m<rmos.size(); m++)
                            {
                                final RModuleOption rmo1 = (RModuleOption)rmos.get(m);
                                final RModuleOption rmo2 = rmo1.copy();
                                rmo2.setOptionId(rmo1.getOptionId());
                                rmo2.setModuleId(newModuleId);
                                rmo2.setIssueTypeId(issueType.getIssueTypeId());
                                rmo2.save();

                                // Save module-option mappings for template types
                                final RModuleOption rmo3 = rmo1.copy();
                                rmo3.setOptionId(rmo1.getOptionId());
                                rmo3.setModuleId(newModuleId);
                                rmo3.setIssueTypeId(issueType.getTemplateId());
                                rmo3.save();
                            }
                        }
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public void deleteModuleMappings()
        throws TorqueException, ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID,
                 getAttributeId());
        crit.addJoin(RAttributeAttributeGroupPeer.GROUP_ID,
                     AttributeGroupPeer.ATTRIBUTE_GROUP_ID);
        crit.add(AttributeGroupPeer.MODULE_ID, (Object)null, Criteria.NOT_EQUAL);
        final List raags = RAttributeAttributeGroupPeer.doSelect(crit);
        for (Iterator i = raags.iterator(); i.hasNext();)
        {
            ((RAttributeAttributeGroup)i.next()).delete();
        }

        crit = new Criteria();
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID, 
                 getAttributeId());
        final List rmas = RModuleAttributePeer.doSelect(crit);
        for (int i=0; i<rmas.size(); i++)
        {
            final RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
            rma.delete(true);
        }
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/ActivitySetTypeManager.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException,ScarabException
    {
        ActivitySetType ttype = null; 
        Object obj = ScarabCache.get(TRANSACTION_TYPE, GET_INSTANCE, 
                                     activitySetTypeName);
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(ActivitySetTypePeer.NAME, activitySetTypeName);
            final List activitySetTypes = ActivitySetTypePeer.doSelect(crit);
            if (activitySetTypes.size() < 1) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetTypenameNotFound, 
                        activitySetTypeName);
            }
            if (activitySetTypes.size() > 1)
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetDuplicateTypename,
                        activitySetTypeName);
            }
            ttype = (ActivitySetType)activitySetTypes.get(0);
            ScarabCache.put(ttype, "ActivitySetType", "getInstance", 
                            activitySetTypeName);
        }
        else 
        {
            ttype = (ActivitySetType)obj;
        }
        
        return ttype;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addUrl(final Attachment attachment, final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return addUrl(null, attachment, user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addUrl(ActivitySet activitySet, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        attachment.setTextFields(user, this, Attachment.URL__PK);
        attachment.save();

        activitySet = attachActivitySet(activitySet, user);

        // Save activity record
        ActivityManager
            .createTextActivity(this, activitySet, ActivityType.URL_ADDED, attachment);
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(final Attachment attachment, final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return addComment(null, attachment, user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(ActivitySet activitySet, 
                                  Attachment attachment, ScarabUser user)
        throws TorqueException, ScarabException
    {
        String comment = attachment.getData();
        if (comment == null || comment.length() == 0)
        {
            throw new ScarabException(L10NKeySet.NoDataInComment);
        }

        activitySet = attachActivitySet(activitySet, user);

        // populates the attachment with data to be a comment
        attachment = AttachmentManager
                        .getComment(attachment, this, user);

        ActivityManager
            .createTextActivity(this, activitySet,
                                ActivityType.COMMENT_ADDED, attachment);

        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.COMMENT_ADDED, activitySet, this, user);            

        index();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public synchronized ActivitySet doSaveFileAttachments(final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return doSaveFileAttachments(null, user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public synchronized ActivitySet doSaveFileAttachments(ActivitySet activitySet,
                                                          final ScarabUser user)
        throws TorqueException, ScarabException
    {
        if (unSavedAttachments == null)
        {
            return activitySet;
        }
        activitySet = attachActivitySet(activitySet, user);

        final Iterator itr = unSavedAttachments.iterator();
        while (itr.hasNext())
        {
            final Attachment attachment = (Attachment)itr.next();
            // make sure we set the issue to the newly created issue
            attachment.setIssue(this);
            attachment.save();

            // Save activity record
            ActivityManager
                .createTextActivity(this, activitySet, ActivityType.ATTACHMENT_CREATED, attachment);

           
        }
        // reset the super method so that the query has to hit the database again
        // so that all of the information is cleaned up and reset.
        super.collAttachments = null;
        // we don't need this one anymore either.
        this.unSavedAttachments = null;
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getEligibleUsers(Attribute attribute)
        throws TorqueException, ScarabException
    {
        ScarabUser[] users = getModule().getEligibleUsers(attribute);
        // remove those already assigned
        List assigneeAVs = getAttributeValues(attribute);
        if (users != null && assigneeAVs != null) 
        {        
            for (int i=users.length-1; i>=0; i--) 
            {
                for (int j=assigneeAVs.size()-1; j>=0; j--) 
                {
                    AttributeValue av = (AttributeValue)assigneeAVs.get(j);
                    Integer avUserId = av.getUserId();
                    Integer userUserId = users[i].getUserId();
                    if ( av != null && avUserId != null && 
                         userUserId != null && 
                         avUserId.equals(userUserId))
                    {
                        users[i] = null;
                        break;
                    }
                }
            }
        }

        List eligibleUsers = new ArrayList(users.length);
        for (int i=0; i<users.length; i++) 
        {
            if (users[i] != null)
            {
                eligibleUsers.add(users[i]);
            }
        }

        return eligibleUsers;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getActivitySet(final ScarabUser user, 
            final Attachment attachment,
            final Integer type)
        throws TorqueException,ScarabException
    {
        ActivitySet activitySet = null;
        if (attachment == null)
        {
            activitySet = ActivitySetManager
                .getInstance(type, user);
        }
        else
        {
            activitySet = ActivitySetManager
                .getInstance(type, user, attachment);
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getActivitySet(ScarabUser user, Integer type)
        throws TorqueException, ScarabException
    {
        return getActivitySet(user, null, type);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doAddDependency(ActivitySet activitySet, Depend depend, 
                                       Issue childIssue, ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check whether the entered issue is already dependent on this
        // Issue. If so, then throw an exception because we don't want
        // to add it again.
        Depend prevDepend = this.getDependency(childIssue, true);
        if (prevDepend != null)
        {
            throw new ScarabException(L10NKeySet.DependencyExists);
        }

        // we definitely want to do an insert here so force it.
        depend.setNew(true);
        depend.setDeleted(false);
        depend.save();

        Attachment comment = depend.getDescriptionAsAttachment(user, this);
        activitySet = attachActivitySet(activitySet, user, comment);

        // Save activity record for the parent issue
        ActivityManager
            .createAddDependencyActivity(this, activitySet, depend);

        // Save activity record for the child issue
        ActivityManager
            .createAddDependencyActivity(childIssue, activitySet, depend);

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private int getNextIssueId(Connection con)
        throws TorqueException, ScarabException
    {
        int id = -1;
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        try
        {
            id = idbroker.getIdAsInt(con, key);
        }
        catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
        return id;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private void setNextIssueId(Connection con, int newID)
        throws TorqueException, ScarabException
    {
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        int nextID = 1;
        
        synchronized (idbroker)
        {
            try
            {
                // Check if the ID table is available and get the next ID
                nextID = idbroker.getIdAsInt(con, key);
            }
            catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }

            if (nextID > newID) {
                getLog()
                    .error("New issue ID "+ newID
                    + "is out of sequence. Must be at least " + nextID);
            }
            else
            {
                try
                {
                    // Now set the next available ID in the table
                    setIdTableKey(con, newID);
                }
                catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Issue move(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user,
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
    	
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // If moving to a new issue type, just change the issue type id
        // otherwise, create fresh issue
        if (getModule().getModuleId().equals(newModule.getModuleId())
            && !getIssueType().getIssueTypeId().equals(newIssueType.getIssueTypeId()))
        {
            newIssue = this;
            newIssue.setIssueType(newIssueType);
            newIssue.save();
        }
        else
        {
            newIssue = newModule.getNewIssue(newIssueType);
        }

        if (newIssue != this)//new issue is not same issue instance as old issue
        {
            // mark issue as moved
            setMoved(true);
            save();

            //add new transaction to new issue
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();      

            // copy attachments: comments/files etc.
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                String oldFilePath = oldA.getFullPath();
                oldA.setIssueId(newIssue.getIssueId());
                oldA.save();
                
                // move file attachment, too
                if (Attachment.FILE__PK.equals(oldA.getTypeId())
                		&& !newIssue.getUniqueId().equals(this.getUniqueId()))
                {
                    try
                    {
                        oldA.copyFileFromTo(oldFilePath, oldA.getFullPath());//copy
                        File f = new File(oldFilePath);//delete old one from disk
                        f.delete();
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }

            // Copy over activity sets for the source issue's previous,
            // and adapt them to new issue
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();

                // If activity set has an attachment, make a copy for new issue
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    // iterate over and move transaction's activities
                    final Activity a = (Activity)j.next();
                    
                    // Only copy transactions that are records of previous move/copies
                    // or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // will be saved when attachments and dependencies are copied.
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                            || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                    	att.setIssueId(newIssue.getIssueId());
                                    	att.setActivity(a);
                                    	att.startActivitySet(as);
                                    	att.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            //adapt all misc activities from old issue
            Iterator iterActivities = getActivitys().iterator();
            while(iterActivities.hasNext()){
            	Activity act = (Activity)iterActivities.next();
            	act.setIssue(newIssue);
            	act.save();
            	newIssue.getActivity(true).add(act); // ?
            }
            
            // Adjust dependencies if its a new issue id
            // (i.e.. moved to new module)
           final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
        }       
       

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "MovedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());

        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "MovedIssueNote"));
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_MOVED,
                                getUniqueId(), newIssue.getUniqueId());

        newIssue.index();
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_MOVED,
                activitySet2, newIssue, user);
        
        return newIssue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Issue copy(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user, 
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // create fresh issue
        newIssue = newModule.getNewIssue(newIssueType);

        if (newIssue != this)
        {
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();

            // Copy over activity sets for the source issue's attribute activities
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();
                ActivitySet newAS = null;
                Attachment newAtt =  null;
                              
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    final Activity a = (Activity)j.next();

                    // Only copy transactions that are records of previous move/copies
                    // Or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // Will be saved when attachments and dependencies are copied
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                        || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // iterate over and copy transaction's activities
                       
                        if(newAS == null){
                        	
                        	 // If old activity set has an attachment, make a copy for new issue
                            if (as.getAttachmentId() != null)
                            {
                                newAtt = as.getAttachment().copy();
                                newAtt.save();
                            }
                        	
            				//init and store new activity set/transaction
                            newAS = new ActivitySet();
                            newAS.setTypeId(as.getTypeId());
                            if (newAtt != null)
                            {
                                newAS.setAttachmentId(newAtt.getAttachmentId());
                            }
                            newAS.setCreatedBy(as.getCreatedBy());
                            newAS.setCreatedDate(as.getCreatedDate());
                            newAS.save();
                        }
                        
                        final Activity newA = a.copy(newIssue, newAS);
                        
                        newIssue.getActivity(true).add(newA);
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                        final AttributeValue newAttVal = att.copy();
                                        newAttVal.setIssueId(newIssue.getIssueId());                                        
                                        newAttVal.setActivity(newA);
                                        newAttVal.startActivitySet(newAS);
                                        newAttVal.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            // add dependencies newly
            final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
            // copy attachments: comments/files etc. and add them, too
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                final Attachment newA = oldA.copy();
                newA.setIssueId(newIssue.getIssueId());
                newA.save();
                final Activity oldAct = oldA.getActivity();
                if (oldAct != null)
                {
                    final ActivitySet activitySet = newIssue.attachActivitySet(null, user);
                    ActivityManager.createTextActivity(newIssue, activitySet,
                        ActivityType.getActivityType(oldA.getActivity().getActivityType()), newA);
                }
                if (Attachment.FILE__PK.equals(newA.getTypeId()))
                {
                    try
                    {
                        oldA.copyFileTo(newA.getFullPath());
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }
        }

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CopiedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());


        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "CopiedIssueNote"));
        
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        // NOTE: There is no distinction bewteen copy and move actions in ActivitySetTypePeer.
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_COPIED,
                                getUniqueId(), newIssue.getUniqueId());
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_COPIED,
                activitySet2, newIssue, user);
        
        newIssue.index();
        
        return newIssue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void addVote(ScarabUser user)
        throws ScarabException, Exception
    {
        // check to see if the user has voted for this issue
        int previousVotes = 0;
        IssueVote issueVote = null;
        Criteria crit = new Criteria()
            .add(IssueVotePeer.ISSUE_ID, getIssueId())
            .add(IssueVotePeer.USER_ID, user.getUserId());
        List votes = IssueVotePeer.doSelect(crit);
        if (votes != null && votes.size() != 0) 
        {
            issueVote = (IssueVote)votes.get(0);
            previousVotes = issueVote.getVotes();
        }
        else 
        {
            issueVote = new IssueVote();
            issueVote.setIssueId(getIssueId());
            issueVote.setUserId(user.getUserId());
        }

        // check if the module accepts multiple votes
        if (!getModule().allowsMultipleVoting() && previousVotes > 0)
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleVoteForUnallowed,
                                      user.getUserName(), 
                                      getUniqueId());
        }
        
        // save the user's vote
        issueVote.setVotes(previousVotes+1);
        issueVote.save();

        // update the total votes for the issue
        crit = new Criteria()
            .add(AttributeValuePeer.ATTRIBUTE_ID, 
                 AttributePeer.TOTAL_VOTES__PK);
        List voteValues = getAttributeValues(crit);
        TotalVotesAttribute voteValue = null;
        if (voteValues.size() == 0) 
        {
            voteValue = new TotalVotesAttribute();
            voteValue.setIssue(this);
            voteValue.setAttributeId(AttributePeer.TOTAL_VOTES__PK);
        }
        else 
        {
            voteValue = (TotalVotesAttribute)voteValues.get(0);
        }
        // Updating attribute values requires a activitySet
        ActivitySet activitySet = attachActivitySet(null, user, null, 
           ActivitySetTypePeer.RETOTAL_ISSUE_VOTE__PK);
        voteValue.startActivitySet(activitySet);
        voteValue.addVote();
        voteValue.save();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void deleteItem(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__DELETE, module)
            || (user.getUserId().equals(getCreatedBy().getUserId()) && isTemplate()))
        {
            setDeleted(true);
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void deleteIssue(ScarabUser user)
        throws Exception, ScarabException
    {        
        if (user.hasPermission(ScarabSecurity.ISSUE__DELETE, this.getModule()))
        {
            ActivitySet activitySet = attachActivitySet(null, user);
            ActivityManager.createDeleteIssueActivity(this, activitySet);
            
            Attachment attachment = new Attachment();
            
            String note = Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "DeletedIssueNote");
            
            attachment.setData(note);
            attachment.setName(note);
            attachment.setTextFields(user, this, Attachment.MODIFICATION__PK);
            attachment.save();         
            
            this.setDeleted(true);
            List dependencies = this.getDependsRelatedByObservedId();
            dependencies.addAll(this.getDependsRelatedByObserverId());
            for (Iterator it = dependencies.iterator(); it.hasNext(); )
            {
                Depend depend = (Depend)it.next();
                if(!depend.getDeleted()){
                	ActivitySet deleteSet = 
                        this.doDeleteDependency(activitySet, depend, user);
                    for (Iterator act = deleteSet.getActivityList().iterator(); act.hasNext(); )
                    {
                        activitySet.addActivity((Activity)act.next());
                    }
                }        
            }
            
            activitySet.setAttachment(attachment);
            
            NotificationManagerFactory.getInstance()
            .addActivityNotification(ActivityType.ISSUE_DELETED,
                    activitySet, this, user);
            
            save();
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet assignUser(ActivitySet activitySet,
                                  final ScarabUser assignee, 
                                  final ScarabUser assigner,
                                  final Attribute attribute, 
                                  final Attachment attachment)
        throws TorqueException,ScarabException
    {                
        final UserAttribute attVal = new UserAttribute();

        activitySet = attachActivitySet(activitySet, assigner, attachment);
        attVal.startActivitySet(activitySet);

        ActivityManager
            .createUserActivity(this, attribute, activitySet,
                                null,
                                null, assignee.getUserId());

        // Save user attribute values
        attVal.setIssue(this);
        attVal.setAttributeId(attribute.getAttributeId());
        attVal.setUserId(assignee.getUserId());
        attVal.setValue(assignee.getUserName());
        attVal.save();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet changeUserAttributeValue(ActivitySet activitySet,
                                                final ScarabUser assignee, 
                                                final ScarabUser assigner, 
                                                final AttributeValue oldAttVal,
                                                final Attribute newAttr,
                                                final Attachment attachment)
        throws TorqueException,ScarabException
    {
        activitySet = attachActivitySet(activitySet, assigner, attachment);
        oldAttVal.startActivitySet(activitySet);

        // Save activity record for deletion of old assignment
        ActivityManager
            .createUserActivity(this, oldAttVal.getAttribute(), 
                                activitySet,
                                null,
                                assignee.getUserId(), null);


        // Save activity record for new assignment
        ActivityManager
            .createUserActivity(this, newAttr, activitySet,
                                null,
                                null, assignee.getUserId());

        // Save assignee value
        oldAttVal.setAttributeId(newAttr.getAttributeId());
        oldAttVal.save();
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet deleteUser(ActivitySet activitySet, 
            final ScarabUser assignee, 
            final ScarabUser assigner,
            final AttributeValue attVal, 
            final Attachment attachment)
        throws TorqueException, ScarabException
    {
        activitySet = attachActivitySet(activitySet, assigner, attachment);
        attVal.startActivitySet(activitySet);

        // Save activity record
        ActivityManager
            .createUserActivity(this, attVal.getAttribute(), 
                                activitySet,
                                null,
                                assignee.getUserId(), null);

        // Save assignee value
        attVal.setDeleted(true);
        attVal.save();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doDeleteDependency(ActivitySet activitySet, 
            Depend oldDepend, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final Issue otherIssue = IssueManager
                        .getInstance(oldDepend.getObserverId(), false);
        final Issue thisIssue = IssueManager
                        .getInstance(oldDepend.getObservedId(), false);

        // get the original object so that we do an update
        oldDepend = thisIssue.getDependency(otherIssue);
        oldDepend.setNew(false);
        oldDepend.setDeleted(true);
        oldDepend.save();

        // need to null out the cache entry so that Issue.getDependency()
        // does not try to return the item from the cache
        ScarabCache.put(null, thisIssue, GET_DEPENDENCY, otherIssue);

        Attachment comment = oldDepend.getDescriptionAsAttachment(user, thisIssue);

        activitySet = thisIssue.attachActivitySet(activitySet, user, comment);
        activitySet = otherIssue.attachActivitySet(activitySet, user, comment);

        ActivityManager
            .createDeleteDependencyActivity(thisIssue, activitySet, oldDepend);
        ActivityManager
            .createDeleteDependencyActivity(otherIssue, activitySet, oldDepend);


        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeUrlDescription(ActivitySet activitySet, 
                                              final ScarabUser user,
                                              final Attachment attachment, 
                                              final String oldDescription)
        throws TorqueException, ScarabException
    {
        final String newDescription = attachment.getName();
        if (!oldDescription.equals(newDescription))
        {
            final Object[] args = {
                oldDescription,
                newDescription,
            };
            String desc = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "UrlDescChangedDesc", args);

            if (desc.length() > 248)
            { 
                desc = desc.substring(0,248) + "...";
            }
            activitySet = attachActivitySet(activitySet, user);
            ActivityManager
                .createTextActivity(this, activitySet,
                                    ActivityType.URL_DESC_CHANGED, attachment,
                                    oldDescription, newDescription);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_DESC_CHANGED, activitySet, this, user);                
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeUrlUrl(ActivitySet activitySet, 
            final ScarabUser user,
            final Attachment attachment, 
            final String oldUrl)
        throws TorqueException, ScarabException
    {
        final String newUrl = attachment.getData();
        if (!oldUrl.equals(newUrl))
        {
            final Object[] args = {
                oldUrl, newUrl
            };
            String desc = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "UrlChangedDesc", args);

            if (desc.length() > 248)
            { 
                desc = desc.substring(0,248) + "...";
            }
            activitySet = attachActivitySet(activitySet, user);

            // Save activity record
            ActivityManager.createTextActivity(
                    this,
                    activitySet,
                    ActivityType.URL_CHANGED,
                    attachment,
                    oldUrl,
                    newUrl);

            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_CHANGED, activitySet, this, user);            
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeDependencyType(ActivitySet activitySet,
                                              final Depend oldDepend,
                                              final Depend newDepend, 
                                              final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldName = oldDepend.getDependType().getName();
        final String newName = newDepend.getDependType().getName();

        final boolean rolesHaveSwitched = 
            ( oldDepend.getObserverId().equals(newDepend.getObservedId()) &&
              oldDepend.getObservedId().equals(newDepend.getObserverId())
            );
        final boolean typeHasChanged = 
            ( !newName.equals(oldName));
        
        final boolean isActive = !newDepend.getDeleted();
        
        // check to see if something changed
        // only change dependency type for non-deleted deps
        if ( isActive && ( rolesHaveSwitched || typeHasChanged ) )
        {
            final Issue otherIssue = (newDepend.getObservedId().longValue() != this.getIssueId().longValue()
            		? IssueManager.getInstance(newDepend.getObservedId(), false)
            		: IssueManager.getInstance(newDepend.getObserverId(), false));

            // always delete an old dependency
            oldDepend.setDeleted(true);
            oldDepend.save();
            // always create a new dependency
            newDepend.setNew(true);
            newDepend.save();

            // need to null out the cache entry so that Issue.getDependency()
            // does not try to return the item from the cache
            ScarabCache.put(null, this, GET_DEPENDENCY, otherIssue);

            final Attachment comment = newDepend.getDescriptionAsAttachment(user, this);

            activitySet = attachActivitySet(activitySet, user, comment);
            activitySet = otherIssue.attachActivitySet(activitySet, user, comment);
            
            ActivityManager
                .createChangeDependencyActivity(this, activitySet, newDepend,
                                    oldName, newName);
            ActivityManager
                .createChangeDependencyActivity(otherIssue, activitySet, newDepend,
                                    oldName, newName);
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setInitialAttributeValues(ActivitySet activitySet, 
            Attachment attachment, 
            final HashMap newValues, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check new values for workflow
        final String msg = doCheckInitialAttributeValueWorkflow(newValues, user);
        if (msg != null)
        {
            throw new TorqueException(msg); //EXCEPTION
        }
        
        if (activitySet == null)
        {
            // Save activitySet record
            activitySet = ActivitySetManager
                .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
            activitySet.save();
        }
        setActivitySetRelatedByCreatedTransId(activitySet);

        // enter the values into the activitySet
        final LinkedMap avMap = getModuleAttributeValuesMap(); 
        final MapIterator iter = avMap.mapIterator();
        while (iter.hasNext())
        {
            final AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            try
            {
                aval.startActivitySet(activitySet);
            }
            catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
        }        
        this.save();

        // create initial issue creation activity
        ActivityManager.createReportIssueActivity(this, activitySet,  
                Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueCreated"));

        // this needs to be done after the issue is created.
        // check to make sure the attachment has data before submitting it.
        final String attachmentData = attachment.getData();
        if (attachmentData != null &&
            attachmentData.length() > 0)
        {
            attachment = AttachmentManager.getReason(attachment, this, user);
            activitySet.setAttachment(attachment);
        }
        activitySet.save();
        
        // need to clear the cache since this is after the 
        // issue is saved. for some reason, things don't
        // show up properly right away.
        ScarabCache.clear();
        
        index();
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setAttributeValues(ActivitySet activitySet,
                                          final HashMap newAttVals,
                                          final Attachment attachment,
                                          final ScarabUser user)
        throws TorqueException,ScarabException
    {
        if (!isTemplate())
        {
            final String msg = doCheckAttributeValueWorkflow(newAttVals, user);
            if (msg != null)
            {
                throw new ScarabException(L10NKeySet.ErrorExceptionMessage,msg); 
            }
        }
        if (attachment != null)
        {
            attachment.setTextFields(user, this, 
                                     Attachment.MODIFICATION__PK);
            attachment.save();
        }
        activitySet = attachActivitySet(activitySet, user, attachment );
        
        final LinkedMap avMap = getModuleAttributeValuesMap(true); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            final String newAttValValue = newAttVal.getValue();

            if (oldAttVal != null &&
            		(newAttValValue != null && !newAttValValue.equals(oldAttVal.getValue())
            		 || newAttValValue == null)
            		 )
            {
                if (newAttValValue != null && newAttValValue.length() > 0)
                {
                    oldAttVal.setProperties(newAttVal);
                }
                else
                {
                    oldAttVal.setDeleted(true);
                }
                oldAttVal.startActivitySet(activitySet);
                oldAttVal.save();
            }
        }
        index();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
       ActivitySet activitySet,
       final ScarabUser user,
       final Attachment attachment,
       final Integer activitySetType 
    )
       throws TorqueException,ScarabException
    {
        if (activitySet == null)
        {
            activitySet = getActivitySet(
               user, attachment,
               activitySetType);
            activitySet.save();
            ScarabCache.clear();
        }

        setLastTransId(activitySet.getActivitySetId());
        save();
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
        ActivitySet activitySet,
        final ScarabUser user,
        final Attachment attachment
    )
        throws TorqueException,ScarabException
    {
        return attachActivitySet(activitySet, user, attachment, ActivitySetTypePeer.EDIT_ISSUE__PK);
    }
              
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
        ActivitySet activitySet,
        final ScarabUser user
    )
        throws TorqueException,ScarabException
    {
        return attachActivitySet(activitySet, user, null, ActivitySetTypePeer.EDIT_ISSUE__PK);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public String doCheckInitialAttributeValueWorkflow(final HashMap newValues, 
                                                       final ScarabUser user)
        throws TorqueException, ScarabException
    {
        String msg = null;
        final Iterator iter = newValues.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            if (attr.isOptionAttribute())
            {
                final AttributeOption toOption = AttributeOptionManager
                     .getInstance(new Integer((String)newValues.get(attrId)));
                msg = WorkflowFactory.getInstance().checkInitialTransition(
                                                    toOption, this, 
                                                    newValues, user);
            }
            if (msg != null)
            {
                break;
            }
        }
        return msg;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public String doCheckAttributeValueWorkflow(final HashMap newAttVals, 
                                                final ScarabUser user)
        throws TorqueException,ScarabException
    {
    	final LinkedMap avMap = getModuleAttributeValuesMap(); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        String msg = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            AttributeOption fromOption = null;
            AttributeOption toOption = null;

            if (newAttVal.getValue() != null)
            {
                if (newAttVal.getAttribute().isOptionAttribute())
                {
                    if (oldAttVal.getOptionId() == null)
                    {
                        fromOption = AttributeOptionManager.getInstance(ScarabConstants.INTEGER_0);
                    }
                    else
                    {
                        fromOption = oldAttVal.getAttributeOption();
                    }
                    toOption = newAttVal.getAttributeOption();
                    msg = WorkflowFactory.getInstance().checkTransition(
                                                        fromOption, 
                                                        toOption, this, 
                                                        newAttVals, user);
                }
                if (msg != null)
                {
                    break;
                }
            }
        }
        return msg;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doEditComment(ActivitySet activitySet, 
            final String newComment, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldComment = attachment.getData();
        if (!newComment.equals(oldComment)) 
        {
            attachment.setData(newComment);
            attachment.save();
           
            activitySet = attachActivitySet( activitySet, user);
            // Save activity record
            ActivityManager
                .createTextActivity(this, null, activitySet,
                                    ActivityType.COMMENT_CHANGED, null, attachment,
                                    oldComment, newComment);
             
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.COMMENT_CHANGED, activitySet,
                    this, user);            
        }
        index();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doDeleteUrl(ActivitySet activitySet, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldUrl = attachment.getData();
        attachment.setDeleted(true);
        attachment.save();

        activitySet = attachActivitySet( activitySet, user);

        // Save activity record
        ActivityManager
            .createTextActivity(this, null, activitySet,
                                ActivityType.URL_DELETED, null, attachment, oldUrl, null);
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doRemoveAttachment(ActivitySet activitySet,
                                          final MutableBoolean physicallyDeleted,
                                          final Attachment attachment, 
                                          final ScarabUser user)
        throws TorqueException, ScarabException
    {
        boolean attachmentPhysicallyDeleted = false;
        final boolean physicalDeletionAllowed = Turbine.getConfiguration()
        .getBoolean("scarab.attachment.remove.permanent",false);

        if(physicalDeletionAllowed)
        {
            attachmentPhysicallyDeleted = attachment.deletePhysicalAttachment();
            physicallyDeleted.set(attachmentPhysicallyDeleted);
        }

        attachment.setDeleted(true);
        attachment.save();

        activitySet = attachActivitySet(activitySet, user);
        
        // Save activity record
        ActivityManager
            .createTextActivity(this, null, activitySet,
                    ActivityType.ATTACHMENT_REMOVED, null, attachment, attachment.getFileName(), null);

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isRequiredAttributeFor(Attribute attribute, ScarabUser user) throws TorqueException, ScarabException
    {
        Module module         = this.getModule();
        IssueType issueType   = this.getIssueType();
        RModuleAttribute rma  = module.getRModuleAttribute(attribute, issueType);

        boolean result = rma.getRequired();
        if(result == false)
        {
            List<Condition> conditions = rma.getConditions();
                
            Iterator<Condition> iter = conditions.iterator();
            while(iter.hasNext())
            {
                Condition condition = iter.next();
                boolean eval = condition.evaluate(user, this);
                result |= eval;
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public SkipFiltering createIssueChecker(String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        return mystate.createIssueChecker(setMarkerFunction, indent);
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public List<Activity> getActivityList() throws ScarabException
    {
        List<Activity> result = null;
/* FIXME: caching is disabled here because new Activities can be
          added to this activityset and the addition does not trigger 
          a reset of this cache (JSS).
        Object obj = ScarabCache.get(this, GET_ACTIVITY_LIST); 
        if (obj == null) 
        {
*/
            Criteria crit = new Criteria()
                .add(ActivityPeer.TRANSACTION_ID, getActivitySetId());
            try
            {
                result = ActivityPeer.doSelect(crit);
            }
            catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
//            ScarabCache.put(result, this, GET_ACTIVITY_LIST);
/*
        }
        else 
        {
            result = (List)obj;
        }
*/
        return result;
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public boolean hasTransitionSealed() throws ScarabException, TorqueException 
    {
        boolean result = false;
        String status = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if (status != null)
        {
            String value = Environment.getConfigurationProperty("scarab.common.status.sealed", null);
            if(value != null)
            {
                
                List<Activity> activities = getActivityList();
                if (activities != null)
                {
                    Iterator<Activity> iter = activities.iterator();
                    if (iter != null)
                    {
                        Activity act = null;
                        try
                        {
                            while((act = iter.next()) != null)
                            {
                                ActivityType at = ActivityType.getActivityType(act.getActivityType());
                                if(at == ActivityType.ATTRIBUTE_CHANGED)
                                {
                                    Attribute att = act.getAttribute();
                                    String name = att.getName();
                                    if(name.equals(status))
                                    {
                                       String oldv = act.getOldValue();
                                       String newv = act.getNewValue();
                                       
                                       if(value.equals(oldv) || value.equals(newv))
                                       {
                                           result = true;
                                           break;
                                       }
                                    }
                                }
                            }
                        }
                        catch (NoSuchElementException nsee)
                        {
                            Throwable th = new Throwable("No such element exception occured.(ignore and assume transitionToSealed=false)");
                            th.printStackTrace();
                            result = false;
                        }
                    }
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                        final Attribute attribute,
                                                        final IssueType issueType)
        throws TorqueException, ScarabException
    {
        return internalUser
            .getRModuleUserAttribute(module, attribute, issueType);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public String setReportingIssue(Issue issue)
        throws ScarabException
    {
        return internalUser.setReportingIssue(issue);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public String setCurrentReport(ReportBridge report)
        throws ScarabException
    {
        return internalUser.setCurrentReport(report);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setHomePage(String homePage)
        throws TorqueException, ScarabException
    {
        internalUser.setHomePage(homePage);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                       final Attribute attribute,
                                                       final IssueType issueType)
        throws TorqueException, ScarabException
    {
        RModuleUserAttribute result = null;
        final Object obj = ScarabCache.get(this, GET_R_MODULE_USERATTRIBUTE, 
                                     module, attribute, issueType); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria(4)
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId())
                .add(RModuleUserAttributePeer.LIST_ID, null);
            if (module == null) 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, 
                         module.getModuleId());
                
            }            
            if (issueType == null) 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                         issueType.getIssueTypeId());                
            }
            
            final List muas = RModuleUserAttributePeer.doSelect(crit);
            if (muas.size() == 1) 
            {
                result = (RModuleUserAttribute)muas.get(0);
            }
            else if (muas.isEmpty())
            {
                result = 
                    getNewRModuleUserAttribute(attribute, module, issueType);
            }
            else 
            {
                throw new ScarabException(L10NKeySet.ExceptionMultipleJDMs);
            }
            ScarabCache.put(result, this, GET_R_MODULE_USERATTRIBUTE, 
                            module, attribute, issueType);
        }
        else 
        {
            result = (RModuleUserAttribute)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public String setReportingIssue(Issue issue)
        throws ScarabException
    {
        String key = null;
        if (issue == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNullIssueForbidden);
        }
        else 
        {
            key = String.valueOf(issueCount++);
            setReportingIssue(key, issue);
        }
        return key;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public String setCurrentReport(ReportBridge report)
        throws ScarabException
    {
        String key = null;
        if (report == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNullReportForbidden);
        }
        else 
        {
            key = String.valueOf(reportCount++);
            setCurrentReport(key, report);
        }
        return key;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void setHomePage(final String homePage)
        throws TorqueException, ScarabException
    {
        if ("ModuleNotReady.vm".equals(homePage)) 
        {
            throw new ScarabException(L10NKeySet.ExceptionForbiddenHomeModuleNotReady);
        }
        final UserPreference up = UserPreferenceManager.getInstance(getUserId());
        up.setHomePage(homePage);
        up.save();
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public boolean deletePhysicalAttachment() 
	throws TorqueException, ScarabException
    {
        File f = new File(getFullPath());
        return f.delete();
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public String getRelativePath()
        throws TorqueException,ScarabException
    {
        if (isNew()) 
        {
            throw new ScarabException(L10NKeySet.ExceptionPathNotSet);
        }        
        String path = null;
        String filename = getFileName();
        if (filename != null) 
        {
            // moduleId/(issue_IdCount/1000)/issueID_attID_filename
            StringBuffer sb = new StringBuffer(30 + filename.length());
            final Issue issue = getIssue();
            sb.append("mod").append(issue.getModule().getQueryKey())
                .append(File.separator)
                .append(issue.getIdCount() / 1000)
                .append(File.separator)
                .append(issue.getUniqueId()).append('_')
                .append(getQueryKey()).append('_')
                .append(filename);
            path = sb.toString();
        }
        return path;
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public String getFullPath()
        throws TorqueException,ScarabException
    {
        String path = null;
        final String relativePath = getRelativePath();
        if (relativePath != null) 
        {
            path = getRepositoryDirectory() + File.separator + relativePath;
        }
        return path;
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public void copyFileTo(final String path)
        throws TorqueException, ScarabException, FileNotFoundException, IOException
    {
        copyFileFromTo(getFullPath(), path);
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public long getSize()
    	throws TorqueException, ScarabException
    {
        if (size== -1) {
        	Log.get(this.getClass().getName()).debug("getSize() reading attachment size from FileSystem");
	        final String path = getFullPath();
	        if (path != null) {
		        final File f = new File(getFullPath());
		        if (f!= null  && f.exists()) {
		            size = f.length();  
	            }
	        }
        } else {
        	Log.get(this.getClass().getName()).debug("getSize() reading attachment size from cache");
        }
        return size;
    }
              
// in java/org/tigris/scarab/om/ReportPeer.java
public static boolean exists(final String name)
        throws TorqueException, ScarabException
    {
        return retrieveByName(name) != null;
    }
              
// in java/org/tigris/scarab/om/ReportPeer.java
public static Report retrieveByName(final String name)
        throws TorqueException, ScarabException
    {
        Report report = null;
        final Criteria crit = new Criteria()
            .add(NAME, name)
            .add(DELETED, false);
        final List reports = doSelect(crit);
        if (reports.size() == 1) 
        {
            report = (Report)reports.get(0);
        }
        else if (reports.size() > 1) 
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleReports,
                                      name);
        }
        
        return report;
    }
              
// in java/org/tigris/scarab/om/AttributeType.java
public static AttributeType getInstance(final String attributeTypeName) 
        throws TorqueException, ScarabException
    {
        AttributeType result = null;
        final Object obj = ScarabCache.get(ATTRIBUTETYPE, GET_INSTANCE, 
                                     attributeTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(AttributeTypePeer.ATTRIBUTE_TYPE_NAME, attributeTypeName);
            final List attributeTypes = AttributeTypePeer.doSelect(crit);
            if(attributeTypes.size() > 1)
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateAttributeTypeName,
                                          attributeTypeName);
            }
            result = (AttributeType)attributeTypes.get(0);
            ScarabCache.put(result, ATTRIBUTETYPE, GET_INSTANCE, 
                            attributeTypeName);
        }
        else 
        {
            result = (AttributeType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Depend.java
public void setObserverUniqueId(String uniqueId)
         throws TorqueException, ScarabException
    {
        if (getDefaultModule() == null)
        {
            throw new ScarabException( L10NKeySet.ExceptionDependInternalWorkflow,
                                       "setDefaultModule()",
                                       "setObserverUniqueId()");
        }
        Issue childIssue = IssueManager.getIssueById(uniqueId.trim());
        if (childIssue == null)
        {
           String code = getDefaultModule().getCode();
           uniqueId = code + uniqueId;
           childIssue = IssueManager.getIssueById(uniqueId);
        }
        super.setObserverId(childIssue.getIssueId());
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped template, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        boolean success = true;
        final Issue issue = IssueManager.getInstance(getIssueId());

        // If it's a module template, user must have Item | Approve 
        //   permission, or its Approved field gets set to false
        if (getScopeId().equals(Scope.PERSONAL__PK)
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        } 
        else
        {
            setApproved(false);
            issue.save();

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");
                
                ScarabUser[] toUsers = module.getUsers(ScarabSecurity.MODULE__EDIT);
                // if the module doesn't have any users, then we need to add at 
                // least ourselves...
                if (toUsers.length == 0)
                {
                    toUsers = new ScarabUser[1];
                    toUsers[0] = user;
                }

                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewTemplateRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx, 
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null, template);
                }
                catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            }
        }
        save();
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getIssue().getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void delete(final ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        final IssueType issueType = getIssueType();

        if (user.hasPermission(ScarabSecurity.MODULE__CONFIGURE, module))
        {
            // Delete both active and inactive attribute groups first
            final List attGroups = issueType.getAttributeGroups(module, false);
            for (int j=0; j<attGroups.size(); j++)
            {
                // delete attribute-attribute group map
                final AttributeGroup attGroup = 
                              (AttributeGroup)attGroups.get(j);
                attGroup.delete();
            }

            // Delete mappings with user attributes
            List rmas = module.getRModuleAttributes(issueType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
            // Delete mappings with user attributes for template type
            final IssueType templateType = issueType.getTemplateIssueType();
            rmas = module.getRModuleAttributes(templateType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
 
            // delete workflows
            WorkflowFactory.getInstance().resetAllWorkflowsForIssueType(module, 
                                                                        issueType);
            // delete templates
            Criteria c = new Criteria()
                .add(IssuePeer.TYPE_ID, templateType.getIssueTypeId());
            final List result = IssuePeer.doSelect(c);
            final List issueIdList = new ArrayList(result.size());
            for (int i=0; i < result.size(); i++) 
            {
                final Issue issue = (Issue)result.get(i);
                issueIdList.add(issue.getIssueId());
            }
            IssuePeer.doDelete(c);
            if (!issueIdList.isEmpty())
            {
                c = new Criteria()
                    .addIn(IssueTemplateInfoPeer.ISSUE_ID, issueIdList);
                IssueTemplateInfoPeer.doDelete(c);
            }
            
            // mit list items
            c = new Criteria()
                .add(MITListItemPeer.MODULE_ID, module.getModuleId())
                .add(MITListItemPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
            final List listItems = MITListItemPeer.doSelect(c);
            final List listIds = new ArrayList(listItems.size());

            for (int i=0; i < listItems.size(); i++) 
            {
                final MITList list = ((MITListItem)listItems.get(i)).getMITList();
                final Long listId = list.getListId();
                if (list.isSingleModuleIssueType() && !listIds.contains(listId))
                {
                    listIds.add(listId);
                }
            }
            MITListItemPeer.doDelete(c);

            if (!listIds.isEmpty())
            {
                // delete single module-issuetype mit lists
                c = new Criteria()
                    .addIn(MITListPeer.LIST_ID, listIds);
                MITListPeer.doDelete(c);

                // delete queries
                c = new Criteria()
                    .addIn(QueryPeer.LIST_ID, listIds);
                QueryPeer.doDelete(c);
            }

            c = new Criteria()
                .add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .add(RModuleIssueTypePeer.ISSUE_TYPE_ID, getIssueTypeId());
            RModuleIssueTypePeer.doDelete(c);
            RModuleIssueTypeManager.removeFromCache(this);
            final List rmits = module.getRModuleIssueTypes();
            rmits.remove(this);
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void delete()
         throws TorqueException, ScarabException
    {                
        int dupeSequence = 0;
        final Integer issueTypeId = getIssueTypeId();
        final IssueType issueType = IssueTypeManager
            .getInstance(SimpleKey.keyFor(issueTypeId), false);
        List attrGroups = null;

        if (isGlobal())
        {
            attrGroups = issueType.getAttributeGroups(null, false);
            dupeSequence =  issueType.getDedupeSequence();
            // Delete issuetype-attribute mapping
            final Criteria crit  = new Criteria()
                .addJoin(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                         RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                .add(RAttributeAttributeGroupPeer.GROUP_ID,
                     getAttributeGroupId())
                .add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, issueTypeId);
            final List results = RIssueTypeAttributePeer.doSelect(crit);
            for (Iterator i = results.iterator(); i.hasNext();)
            {
                ((RIssueTypeAttribute)i.next()).delete();
            }
        }
        else
        {
            if (issueType.getLocked())
            { 
                
                throw new ScarabException(L10NKeySet.ExceptionGroupDeleteForbidden,
                          this.getName(),
                          issueType.getName());
            }            
            else
            {
                final Module module = getModule();
                attrGroups = getIssueType().getAttributeGroups(module, false);
                dupeSequence =  module.getDedupeSequence(issueType);
                // Delete module-attribute mapping
                final Criteria crit  = new Criteria()
                    .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                             RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                    .add(RAttributeAttributeGroupPeer.GROUP_ID,
                             getAttributeGroupId())
                    .add(RModuleAttributePeer.MODULE_ID,
                         getModuleId());
                final Criteria.Criterion critIssueType = crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                getIssueTypeId(), Criteria.EQUAL);
                critIssueType.or(crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                issueType.getTemplateId(), Criteria.EQUAL));
                crit.and(critIssueType);
                final List results = RModuleAttributePeer.doSelect(crit);
                for (int i=0; i<results.size(); i++)
                {
                    final RModuleAttribute rma = (RModuleAttribute)results.get(i);
                    rma.delete();
                }
            }
        }

        // Delete attribute - attribute group mapping
        Criteria crit2 = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, getAttributeGroupId());
        RAttributeAttributeGroupPeer.doDelete(crit2);


        // Delete the attribute group
        final int order = getOrder();
        crit2 = new Criteria()
            .add(AttributeGroupPeer.ATTRIBUTE_GROUP_ID, getAttributeGroupId());
        AttributeGroupPeer.doDelete(crit2);
        IssueTypeManager.getManager().refreshedObject(this);
            
        // Adjust the orders for the other attribute groups
        for (int i=0; i<attrGroups.size(); i++)
        {
            final AttributeGroup tempGroup = (AttributeGroup)attrGroups.get(i);
            int tempOrder = tempGroup.getOrder();
            if (tempGroup.getOrder() > order)
            {
                if (tempOrder == dupeSequence + 1 && tempOrder == 3)
                {
                    tempGroup.setOrder(tempOrder - 2);
                }
                else
                {
                    tempGroup.setOrder(tempOrder - 1);
                }
                tempGroup.save();
            }
        } 
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void addAttribute(final Attribute attribute)
         throws TorqueException, ScarabException
    {                
        final IssueType issueType = getIssueType();
        final Module module = getModule();

        // add attribute group-attribute mapping
        final RAttributeAttributeGroup raag =
            addRAttributeAttributeGroup(attribute);
        raag.save();
        if (Log.get().isDebugEnabled()) 
        {
            Log.get().debug("Calling getAttributes() from addAttribute in order to add attribute id="
                            + attribute.getAttributeId() + " to the List");
        }
        // FIXME! Distributed cache buster, cache should be invalidated.
        final List attributes = getAttributes();
        if (!attributes.contains(attribute)) 
        {
            attributes.add(attribute);
        }
        
        final List allOptions = attribute.getAttributeOptions(false);
        // remove duplicate options
        // FIXME! why would we ever want Attribute.getAttributeOptions to
        // return dupes, should this code be in that method?
        final ArrayList options = new ArrayList();
        for (int i=0; i<allOptions.size(); i++)
        {
            final AttributeOption option = (AttributeOption)allOptions.get(i);
            if (!options.contains(option))
            {
                options.add(option);
            }
        }

        if (isGlobal())
        {
            // this is a global attribute group
            // add issuetype-attribute groupings
            issueType.addRIssueTypeAttribute(attribute);

            // add issueType-attributeoption mappings
            for (int j=0;j < options.size();j++)
            {
                final AttributeOption option = (AttributeOption)options.get(j);
                final List roos = option.getROptionOptionsRelatedByOption2Id();
                final ROptionOption roo = (ROptionOption)roos.get(0);
                final RIssueTypeOption rio = new RIssueTypeOption();
                rio.setIssueTypeId(issueType.getIssueTypeId());
                rio.setOptionId(option.getOptionId());
                rio.setOrder(roo.getPreferredOrder());
                rio.setWeight(roo.getWeight());
                // making sure error is recorded in same log as our other
                // debugging for pcn 17683.
                try 
                {
                    rio.save();                    
                }
                catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
            }
        }
        else
        {
            // add module-attribute groupings
            module.addRModuleAttribute(issueType, attribute);

            // add module-attributeoption mappings
            for (int j=0;j < options.size();j++)
            {
                final AttributeOption option = (AttributeOption)options.get(j);
                final List roos = option.getROptionOptionsRelatedByOption2Id();
                final ROptionOption roo = (ROptionOption)roos.get(0);
                final RModuleOption rmo = new RModuleOption();
                rmo.setModuleId(getModuleId());
                rmo.setIssueTypeId(issueType.getIssueTypeId());
                rmo.setOptionId(option.getOptionId());
                rmo.setDisplayValue(option.getName());
                rmo.setOrder(roo.getPreferredOrder());
                rmo.setWeight(roo.getWeight());
                rmo.save();

                // add module-attributeoption mappings to template type
                final IssueType templateType = IssueTypeManager
                    .getInstance(issueType.getTemplateId(), false);
                final RModuleOption rmo2 = module.
                     addRModuleOption(templateType, option);
                rmo2.save();
            }
        }
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void deleteAttribute(final Attribute attribute, 
            final ScarabUser user,
            final Module module)
         throws TorqueException, ScarabException
    {                
        String permission = null;
        if (isGlobal())
        {
            permission = (ScarabSecurity.DOMAIN__EDIT);
        }
        else
        {
            permission = (ScarabSecurity.MODULE__CONFIGURE);
        }
        if (user.hasPermission(permission, module))
        {
            final IssueType issueType = getIssueType();
            final IssueType template = IssueTypeManager.getInstance
                                 (issueType.getTemplateId());
            boolean success = true;

            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
            if (isGlobal())
            {
                // This is a global attribute group
                // Remove attribute - issue type mapping
                final List rias = issueType.getRIssueTypeAttributes
                                     (false, AttributePeer.NON_USER);
                if (ria != null) 
                {
                    ria.delete();                    
                }
                if (rias != null) 
                {
                    rias.remove(ria);        
                }
            }
            else
            {
                // Check if attribute is locked
                if (ria != null && ria.getLocked())
                {
                    success = false;
                    throw new TorqueException(attribute.getName() + "is locked"); //EXCEPTION
                }
                else
                {
                    // Remove attribute - module mapping
                    final List rmas = module.getRModuleAttributes(issueType, false,
                                                            AttributePeer.NON_USER);    
                    final RModuleAttribute rma = module
                        .getRModuleAttribute(attribute, issueType);
                    if(rma != null)rma.delete();
                    WorkflowFactory.getInstance().deleteWorkflowsForAttribute
                                                  (attribute, module, issueType);
                    if(rma != null)rmas.remove(rma);

                    // Remove attribute - module mapping from template type
                    final RModuleAttribute rma2 = module
                                   .getRModuleAttribute(attribute, template);
                    if(rma2 != null)
                    {
                        rma2.delete();
                        rmas.remove(rma2);
                    }
                }
            }

            if (success)
            {
                // Remove attribute - group mapping
                final RAttributeAttributeGroup raag = 
                    getRAttributeAttributeGroup(attribute);
                raag.delete();

                if (attribute.isOptionAttribute())
                {
                    if (isGlobal())
                    { 
                        // global attributeGroup; remove issuetype-option maps
                        final List rios = issueType.getRIssueTypeOptions(attribute);
                        if (rios != null)
                        {
                            for (int i = 0; i<rios.size();i++)
                            {
                                ((RIssueTypeOption) rios.get(i))
                                    .delete(user, module);
                            }
                        }
                    }
                    else
                    {
                        // Remove module-option mapping
                        final List rmos = module.getRModuleOptions(attribute, issueType);
                        if (rmos != null)
                        {
                            rmos.addAll(module.getRModuleOptions(attribute, template));
                            for (int j = 0; j<rmos.size();j++)
                            {
                                final RModuleOption rmo = (RModuleOption)rmos.get(j);
                                 // rmo's may be inherited by the parent module.
                                 // don't delete unless they are directly associated
                                 // with this module.  Will know by the first one.
                                 if (rmo.getModuleId().equals(module.getModuleId())) 
                                 {
                                     rmo.delete();
                                 }
                                 else 
                                 {
                                     break;
                                 } 
                             }
                         }
                     }
                 }
             }
         }
         else
         {
             throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
         }            
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
              
// in java/org/tigris/scarab/om/AttachmentType.java
public static AttachmentType getInstance(String attachmentTypeName)
        throws TorqueException,ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(BaseAttachmentTypePeer.ATTACHMENT_TYPE_NAME, attachmentTypeName);
        List attachmentTypes = AttachmentTypePeer.doSelect(crit);
        if(attachmentTypes.size() > 1)
        {
            throw new ScarabException(L10NKeySet.ExceptionAttachmentDuplicateTypename);
        }
        return (AttachmentType)attachmentTypes.get(0);
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getTemplates(Module module, IssueType issueType,
                                    ScarabUser user, String sortColumn, 
                                    String sortPolarity, String type)
        throws TorqueException, ScarabException
    {
        List templates = null;
        Serializable[] key = {TEMPLATE_PEER, GET_TEMPLATES, module,
            issueType, user, sortColumn, sortPolarity, type};
        Object obj = ScarabCache.get(key);
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(IssuePeer.MODULE_ID, module.getModuleId())
                .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MOVED, 0)
                .addJoin(ActivitySetPeer.TRANSACTION_ID, 
                         ActivityPeer.TRANSACTION_ID) 
                .addJoin(IssuePeer.ISSUE_ID, 
                         ActivityPeer.ISSUE_ID) 
                .add(IssuePeer.TYPE_ID, issueType.getTemplateId())
                .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID);
            crit.setDistinct();

            Criteria.Criterion cGlob = crit.getNewCriterion(
                IssueTemplateInfoPeer.SCOPE_ID, Scope.MODULE__PK,
                Criteria.EQUAL);
            cGlob.and(crit.getNewCriterion(IssueTemplateInfoPeer.APPROVED, 
                                           Boolean.TRUE, Criteria.EQUAL));
            Criteria.Criterion cPriv = crit.getNewCriterion(
                ActivitySetPeer.CREATED_BY, user.getUserId(),  
                Criteria.EQUAL);
            cPriv.and(crit.getNewCriterion(
                IssueTemplateInfoPeer.SCOPE_ID, Scope.PERSONAL__PK, 
                Criteria.EQUAL));

            if (TYPE_PRIVATE.equals(type))
            {
                crit.add(cPriv);
            }
            else if (TYPE_GLOBAL.equals(type))
            {
                crit.add(cGlob);
            }
            else
            {
                // All templates
                cGlob.or(cPriv);
                crit.add(cGlob);
            }

            // Add sort criteria
            if (sortColumn.equals("desc"))
            {
                addSortOrder(crit, IssueTemplateInfoPeer.DESCRIPTION, 
                             sortPolarity);
            }
            else if (sortColumn.equals("avail"))
            {
                crit.addJoin(IssueTemplateInfoPeer.SCOPE_ID,
                             ScopePeer.SCOPE_ID);
                addSortOrder(crit, ScopePeer.SCOPE_NAME, sortPolarity);
            }
            else if (!sortColumn.equals("user"))
            {
                // sort by name
                addSortOrder(crit, IssueTemplateInfoPeer.NAME, sortPolarity);
            }
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, key);
        }
        else 
        {
            templates = (List)obj;
        }
        if (sortColumn.equals("user"))
        {
            templates = sortByCreatingUser(templates, sortPolarity);
        }
        return templates;
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getUserTemplates(ScarabUser user, Module module,IssueType issueType)
        throws TorqueException, ScarabException
    {
        List templates = null;
        Object obj = ScarabCache.get(TEMPLATE_PEER, GET_USER_TEMPLATES, user);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
            .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID)
            .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MODULE_ID, module.getModuleId())
            .addJoin(ActivitySetPeer.TRANSACTION_ID, 
                     ActivityPeer.TRANSACTION_ID) 
                .addJoin(IssuePeer.ISSUE_ID, 
                         ActivityPeer.ISSUE_ID) 
            .add(IssuePeer.TYPE_ID, issueType.getTemplateId())
            .add(ActivitySetPeer.CREATED_BY, user.getUserId());
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, TEMPLATE_PEER, GET_USER_TEMPLATES, user);
        }
        else 
        {
            templates = (List)obj;
        }
        return templates;
    }
              
// in java/org/tigris/scarab/xmlrpc/NewTicketHandler.java
public String createNewTicket( String moduleCode, 
								   String issueTypeName, 
								   String userName, 
								   Hashtable attribs) throws TorqueException, ScarabException {
		
		//init environment for the new issue
		Module module = ModuleManager.getInstance(null, null, moduleCode);
		IssueType issueType = IssueType.getInstance(issueTypeName);
		Issue issue = module.getNewIssue(issueType);
		ScarabUser user = ScarabUserManager.getInstance(userName);
        
        Attachment reason = new Attachment();
        reason.setData("Created by xmlrpc");
        reason.setName("reason");
        
        //init issue, set and store attributes
		ActivitySet activitySet = null;
        activitySet = issue.setInitialAttributeValues(activitySet, reason, new HashMap(), user);

        // Save any unsaved attachments as part of this ActivitySet as well.
        setAttributes(issue,activitySet,reason,user,attribs);
        activitySet = issue.doSaveFileAttachments(activitySet, user);
        activitySet.save();
        
        return issue.getUniqueId();
	}
              
// in java/org/tigris/scarab/xmlrpc/NewTicketHandler.java
private void setAttributes(Issue issue, ActivitySet activitySet, Attachment attachment, ScarabUser user, Hashtable attribs) throws TorqueException, ScarabException {

        LinkedMap avMap = issue.getModuleAttributeValuesMap(false); 
        HashMap newValues = new HashMap();
        
        for (MapIterator i = avMap.mapIterator();i.hasNext();) 
        {
            AttributeValue aval = (AttributeValue)avMap.get(i.next());
        	String key = aval.getAttribute().getName();
        	String newValue = (String)attribs.get(key);
        	
        	if (newValue != null) {
        		AttributeValue newVal = aval.copy();
        		newVal.setValue(newValue);
				newValues.put(aval.getAttributeId(),newVal);
        	}
        }
        issue.setAttributeValues(activitySet, newValues, attachment, user);
	}
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public boolean canMakeTransitionsFrom(ScarabUser user,
    		IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption) throws ScarabException
    {
    	Module module = user.getCurrentModule();
        boolean result = false;
        List availableOptions = getAvailableOptions(issueType, attribute, module);		
        List allTransitions = TransitionPeer.getTransitionsFrom(availableOptions, attribute, fromOption);
        Iterator iter = allTransitions.iterator();
        if(!iter.hasNext())
        {
        	return true; // no transition rules available -> any transition possible
        }
        
        while (!result && iter.hasNext())
        {
            Object obj = iter.next();
            Transition tran = (Transition) obj;

			if(transitionIsSupportedByOptions(tran, availableOptions))
			{
                Role requiredRole = tran.getRole();
                if (requiredRole != null)
                { 	// A role is required for this transition to be
                	// allowed
                	result = user.hasRoleInModule(requiredRole, module);
                }
                else
                {
                    result = true;
                }
			}
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public List getTransitions(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        Module module = user.getCurrentModule();
        List result = null;
        List availableOptions = getAvailableOptions(issueType, attribute, module);

        Iterator optionsIter = availableOptions.iterator();
        while(optionsIter.hasNext())
        {
            RModuleOption rmoduleOption = (RModuleOption)optionsIter.next();
            AttributeOption fromOption;
            try
            {
                fromOption = rmoduleOption.getAttributeOption();
            }
            catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            List list = getTransitionsFrom(user,issueType,attribute,fromOption);
            if(list != null)
            {
                if(result == null)
                {
                    result = list;
                }
                else
                {
                    result.addAll(list);
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public TransitionNode getTransitionTree(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        Module module = user.getCurrentModule();
        TransitionNode result = null;
        List availableOptions = getAvailableOptions(issueType, attribute, module,false);
        List visitedTransitions = null;
        Iterator optionsIter = availableOptions.iterator();
        while(optionsIter.hasNext())
        {
            RModuleOption rmoduleOption = (RModuleOption)optionsIter.next();
            AttributeOption fromOption;
            try
            {
                fromOption = rmoduleOption.getAttributeOption();
            }
            catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            List list = getTransitionsFrom(user,issueType,attribute,fromOption,false);
            if(list != null)
            {
                if(result == null)
                {
                    result = new TransitionNode(fromOption);
                }
                for(int index=0; index < list.size(); index++)
                {
                    Transition t = (Transition)list.get(index);
                    if(visitedTransitions == null)
                    {
                        visitedTransitions = new ArrayList();
                    }
                    if(visitedTransitions.contains(t))
                    {
                        continue;
                    }
                    visitedTransitions.add(t);
                    TransitionNode child = result.addNode(t);
                    getTransitionTree(user, issueType, attribute, t.getTo(), child, visitedTransitions);
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public void getTransitionTree(ScarabUser user,
            IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption,
            TransitionNode node,
            List visitedTransitions) throws ScarabException
    {
        List list = getTransitionsFrom(user,issueType,attribute,fromOption,false);
        if(list != null)
        {
            for(int index=0; index < list.size(); index++)
            {
                Transition t = (Transition)list.get(index);
                if(visitedTransitions.contains(t))
                {
                    continue;
                }
                visitedTransitions.add(t);
                TransitionNode child = node.addNode(t);
                AttributeOption toOption = t.getTo();
                TransitionNode parent = node.getParent();
                while(parent != null && !parent.getOption().equals(toOption))
                {
                    parent = parent.getParent();
                }
                if(parent == null)
                {
                    getTransitionTree(user,issueType,attribute,t.getTo(),child,visitedTransitions);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private List getAvailableOptions(IssueType issueType, Attribute attribute, Module module) throws ScarabException
    {
        return getAvailableOptions(issueType, attribute, module, true);
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private List getAvailableOptions(IssueType issueType, Attribute attribute, Module module, boolean activeOnly) throws ScarabException
    {
        List availableOptions;
        try 
        {
            availableOptions = module.getOptionTree(attribute,issueType,activeOnly);
        } catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
        return availableOptions;
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public List getTransitionsFrom(ScarabUser user,
            IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption) throws ScarabException
    {
        return getTransitionsFrom(user, issueType, attribute, fromOption, false);
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private List getTransitionsFrom(ScarabUser user,
                                   IssueType issueType,
                                   Attribute attribute,
                                   AttributeOption fromOption,
                                   boolean activeOnly) throws ScarabException
                           {
        Module module = user.getCurrentModule();
        List result;
        List availableOptions = getAvailableOptions(issueType, attribute, module, activeOnly);
        List allTransitions = TransitionPeer.getTransitionsFrom(availableOptions, attribute, fromOption);
        Iterator iter = allTransitions.iterator();
        if(iter.hasNext())
        {
            result = new ArrayList();
            while (iter.hasNext())
            {
                Object obj = iter.next();
                Transition transition = (Transition) obj;

                boolean isSupportedByOptions = transitionIsSupportedByOptions(transition, availableOptions);
                if (isSupportedByOptions || !activeOnly)
                {
                    boolean addTransition;
                    
                    if(activeOnly)
                    {
                        Role requiredRole = transition.getRole();
                        if (requiredRole != null)
                        {
                            // A role is required for this transition to be allowed
                            addTransition = user.hasRoleInModule(
                                    requiredRole, module);
                        }
                        else
                        {
                            addTransition = true;
                        }
                    }
                    else
                    {
                        addTransition = true;
                    }

                    if (addTransition)
                    {
                        result.add(transition);
                    }
                }
            }
        }
        else
        {
            result = null; // no transitions defined -> all transitions allowed
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public boolean canMakeTransition(ScarabUser user,
                                     AttributeOption fromOption, 
                                     AttributeOption toOption,
                                     Issue issue)
        throws ScarabException

    {
        return true;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public List getTransitions(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public TransitionNode getTransitionTree(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public List getTransitionsFrom(ScarabUser user,
            IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption) throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public boolean canMakeTransitionsFrom(ScarabUser user,
    		IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption)
    throws ScarabException
    {
    	return true;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public String checkTransition(AttributeOption fromOption, 
                                  AttributeOption toOption,
                                  Issue issue, Map newAttVals,
                                  ScarabUser user)
        throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public String checkInitialTransition(AttributeOption toOption,
                                         Issue issue, Map newAttVals,
                                         ScarabUser user)
        throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public OptionWorkflow getWorkflowForRole(AttributeOption fromOption, 
                                             AttributeOption toOption,
                                             String roleName,
                                             Module module,
                                             IssueType issueType)
        throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public List getWorkflowsForIssueType(IssueType issueType)
        throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public List getWorkflowsForRoleList(AttributeOption fromOption, 
                                        AttributeOption toOption,
                                        List roleNames, 
                                        Module module,
                                        IssueType issueType)
        throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public OptionWorkflow inherit(AttributeOption fromOption, 
                                   AttributeOption toOption,
                                   String roleName, Module module,
                                   IssueType issueType)
        throws ScarabException
    {
        return null;
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void saveWorkflow(AttributeOption fromOption, 
                             AttributeOption toOption,
                             String roleName, Module module,
                             IssueType issueType, WorkflowRules workflowRule)
        throws ScarabException
    {
        //nothing
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void resetWorkflow(AttributeOption fromOption, 
                              AttributeOption toOption,
                              String roleName, Module module,
                              IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void resetWorkflows(String roleName, Module module, IssueType issueType,
                               boolean initial)
        throws ScarabException
    {
       // nothing
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void deleteWorkflowsForOption(AttributeOption option,
                                         Module module, IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void deleteWorkflowsForAttribute(Attribute attr, Module module, 
                                            IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void addIssueTypeWorkflowToModule(Module module, 
                                            IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void copyIssueTypeWorkflows(IssueType issueType, IssueType newIssueType)
        throws ScarabException
    {
       // nothing
    }
              
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void resetAllWorkflowsForIssueType(Module module, 
                                              IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public  SkipFiltering createIssueChecker(String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        String result = "";
        List<Attribute> attributes = null;
        Module module = issue.getModule();
        IssueType issueType = issue.getIssueType();
        attributes = issueType.getActiveAttributes(module);
        Iterator<Attribute> iter = attributes.iterator();
        while (iter.hasNext())
        {
            Attribute attribute = iter.next();
            RModuleAttribute rma  = module.getRModuleAttribute(attribute, issueType);
            result += createIssueChecker(rma, setMarkerFunction, indent);
        }
        
        String prepend;
        if(result.length() > 0)
        {
            prepend="\n";
        }
        else
        {
            prepend = "/* No conditional attributes found for this module/issueType */";
        }
        
        return new SimpleSkipFiltering(prepend+result);
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
private String createIssueChecker(RModuleAttribute rma, String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        String result = "";
        boolean isRequired = rma.getRequired();
        if(!isRequired)
        {
            List<Condition> conditions = rma.getConditions();
                
            Iterator<Condition> iter = conditions.iterator();
            while(iter.hasNext())
            {
                Condition condition = iter.next();
                result += condition.createConditionCheckerScript(rma, setMarkerFunction, indent);
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
public static Workflow getInstance() throws ScarabException
    {
        Workflow wf = null;
        String className = null;
        try
        {
            if (getForceUseDefault())
            {
                wf = (Workflow) DefaultWorkflow.class.newInstance();
            }
            else
            {
                List classNames = Turbine.getConfiguration()
                    .getList("scarab.workflow.classname");
                if (classNames.size() > 0)
                {
                    className = (String) classNames.get(0);
                }
    
                Class wfClass = (className != null ? Class.forName(className) :
                                 DefaultWorkflow.class);
                wf = (Workflow) wfClass.newInstance();
            }
        }
        catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
        catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
        catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
        return wf;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
void doHandleDependencies()
        throws ScarabException, TorqueException
    {
        LOG.debug("Number of dependencies found: " + allDependencies.size());
        for (Iterator itr = allDependencies.iterator(); itr.hasNext();)
        {
            final Object[] data = (Object[])itr.next();
            final ActivitySet activitySetOM = (ActivitySet) data[0];
            final XmlActivity activity = (XmlActivity) data[1];
            

            final Dependency dependency = activity.getDependency();
            final String child = (String)issueXMLMap.get(dependency.getChild());
            final String parent = (String)issueXMLMap.get(dependency.getParent());
            if (parent == null || child == null)
            {
                if(null != parent || null != child)
                {
                    // add a comment into the issue that informs of the dependency
                    final Issue issueOM = IssueManager.getIssueById(null == parent ? child : parent);
                    final Attachment attachmentOM = new Attachment();
                    attachmentOM.setName("comment");
                    attachmentOM.setTypeId(Attachment.COMMENT__PK);
                    attachmentOM.setMimeType("text/plain");
                    // TODO i18n this
                    final String text = "Dependency \"" 
                            + parent + " (originally " + dependency.getParent() + ") " + dependency.getType() + ' ' 
                            + child + " (originally " + dependency.getParent()
                        + ") \" was not imported due to " 
                        + (null == parent ? dependency.getParent() : dependency.getChild()) + " not being resolved";
                    attachmentOM.setData(text);                    
                    issueOM.addComment(attachmentOM, ScarabUserManager.getInstance("Administrator"));
                }
                
                LOG.debug("Could not find issues: parent: " + parent + " child: " + child);
                LOG.debug("----------------------------------------------------");
                continue;
            }
            LOG.debug("doHandleDependencies: " + dependency);
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                LOG.error("[TODO] update-same-db import type not yet implemented");
                // trick here is that dependencies don't have ids or unique keys to find the 
                //  correct existing instance against.
            }
            else
            {
                try
                {
                    final String type = dependency.getType();
                    final Depend newDependOM = DependManager.getInstance();
                    final Issue parentIssueOM = IssueManager.getIssueById(parent);
                    final Issue childIssueOM = IssueManager.getIssueById(child);
                    newDependOM.setDefaultModule(parentIssueOM.getModule());
                    newDependOM.setObservedId(parentIssueOM.getIssueId());
                    newDependOM.setObserverId(childIssueOM.getIssueId());
                    newDependOM.setDependType(type);
                    LOG.debug("Dep: " + type + " Parent: " + parent + " Child: " + child);
                    LOG.debug("XML Activity id: " + activity.getId());
                    if (activity.isAddDependency())
                    {
                        parentIssueOM
                          .doAddDependency(activitySetOM, newDependOM, childIssueOM, null);
                        LOG.debug("Added Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isDeleteDependency())
                    {
                        parentIssueOM
                          .doDeleteDependency(activitySetOM, newDependOM, null);
                        LOG.debug("Deleted Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isUpdateDependency())
                    {
                        final Depend oldDependOM = parentIssueOM.getDependency(childIssueOM);
                        if (oldDependOM == null)
                        {
                            throw new IllegalArgumentException ("Whoops! Could not find the original dependency!"); //EXCEPTION
                        }
                        // we definitely know we are doing an update here.
                        newDependOM.setDeleted(false);
                        parentIssueOM
                          .doChangeDependencyType(activitySetOM, oldDependOM, newDependOM, null);
                        LOG.debug("Updated Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("Old Type: " + oldDependOM.getDependType().getName() + " New type: " + newDependOM.getDependType().getName());
                        LOG.debug("----------------------------------------------------");
                    }
                }
                catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }                
            }
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
public void addIssue(final XmlIssue issue)
        throws ScarabException
    {
        LOG.debug("Module.addIssue(): " + issue.getId());
        try
        {
            if (inValidationMode)
            {
                importErrors.setParseContext((issue.hasModuleCode()
                    ?"":module.getCode()) + issue.getId());
                doIssueValidateEvent(getModule(), issue);
            }
            else
            {
                doIssueEvent(getModule(), issue);
            }
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
        catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
        finally
        {
            importErrors.setParseContext(null);
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Issue createNewIssue(final XmlModule module, final XmlIssue issue, final String id)
        throws TorqueException,ScarabException
    {
        // get the instance of the module
        final Module moduleOM = getModuleForIssue(module,issue);
        // get the instance of the issue type
        final IssueType issueTypeOM = IssueType.getInstance(issue.getArtifactType());
        issueTypeOM.setName(issue.getArtifactType());
        // get me a new issue since we couldn't find one before
        final Issue issueOM = Issue.getNewInstance(moduleOM, issueTypeOM);

        // The import data may nominate its ID
        if (id != null) {
            // This will cause Issue.save() to use this ID
            issueOM.setFederatedId(id);
        }
        // create the issue in the database

        // Add the mapping between the issue id and the id that was created.
        // This mapping is used dependency checking and printing out in 
        // results list of original id and new id. The original issue id can be
        // null. In this case, have the original id show as 'null (index)'
        // where index is count into the issueXMLMap. We add the index to keep
        // the key unique. This substitute original id also shouldn't interfere
        // w/ issueXMLMap's use dependency checking.
        String issueID = "Null (" + Integer.toString(issueXMLMap.size()) + ")";
        if(issue.getId() != null)
        {
            issueID = (issue.hasModuleCode()?"":module.getCode())
                + issue.getId();
        }
        issueXMLMap.put(issueID, issueOM.getUniqueId());

        LOG.debug("Created new Issue: " + issueOM.getUniqueId());
        return issueOM;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueEvent(final XmlModule module, final XmlIssue issue)
        throws TorqueException,ScarabException,ParseException
    {
/////////////////////////////////////////////////////////////////////////////////  
        // Get me an issue
        Issue issueOM = null;
        final String issueID = (issue.hasModuleCode() ? "" : module.getCode()) + issue.getId();
        if (getImportTypeCode() == CREATE_SAME_DB || getImportTypeCode() == CREATE_DIFFERENT_DB)
        {
            // Check if the new issue nominates an ID and if the database does
            // not already contain an issue with that ID
            if (issue.getId() != null && IssueManager.getIssueById(issueID) == null)
            {
                // Create the new issue with the nominated ID
                issueOM = createNewIssue(module, issue, issue.getId());
            }
            else
            {
                // Crate the new issue with an automatically allocated ID
                issueOM = createNewIssue(module, issue, null);
            }
        }
        else if (getImportTypeCode() == UPDATE_SAME_DB) // nice to specify just for searching/refactoring
        {
            issueOM = IssueManager.getIssueById(issueID);
            
            if (issueOM == null)
            {
                issueOM = createNewIssue(module, issue, null);
            }
            else
            {
                LOG.debug("Found Issue in db: " + issueOM.getUniqueId());
            }
        }

/////////////////////////////////////////////////////////////////////////////////  

        // Loop over the XML activitySets
        final List activitySets = issue.getActivitySets();
        LOG.debug("-----------------------------------");
        LOG.debug("Number of ActivitySets in Issue: " + activitySets.size());
        for (Iterator itr = activitySets.iterator(); itr.hasNext();)
        {
            final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
            LOG.debug("Processing ActivitySet: " + activitySet.getId());

/////////////////////////////////////////////////////////////////////////////////  
            // Deal with the attachment for the activitySet
            final XmlAttachment activitySetAttachment = activitySet.getAttachment();
            Attachment activitySetAttachmentOM = null;
            if (activitySetAttachment != null)
            {
                if (getImportTypeCode() == UPDATE_SAME_DB)
                {
                    try
                    {
                        activitySetAttachmentOM = AttachmentManager
                            .getInstance(activitySetAttachment.getId());
                        LOG.debug("Found existing ActivitySet Attachment");
                    }
                    catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
                }
                else
                {
                    activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    LOG.debug("Created ActivitySet Attachment object");
                }
            }
            else
            {
                LOG.debug("OK- No Attachment in this ActivitySet");
            }

/////////////////////////////////////////////////////////////////////////////////  
            // Attempt to get the activitySet OM
            boolean alreadyCreated = false;
            ActivitySet activitySetOM = null;
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                try
                {
                    activitySetOM = ActivitySetManager.getInstance(activitySet.getId());
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in db: " + activitySetOM.getActivitySetId());
                }
                catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            }
            else
            {
                // first try to get the ActivitySet from the internal map
                if (activitySetIdMap.containsKey(activitySet.getId()))
                {
                    activitySetOM = ActivitySetManager.getInstance(
                        (String)activitySetIdMap.get(activitySet.getId()));
                    alreadyCreated = true;
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in map: " + activitySetOM.getActivitySetId());
                }
                else // it hasn't been encountered previously
                {
                    activitySetOM = ActivitySetManager.getInstance();
                    LOG.debug("Created new ActivitySet");
                }
            }

            final ScarabUser activitySetCreatedByOM = findUser(activitySet.getCreatedBy());
            
            if (LOG.isDebugEnabled())
            {
                LOG.debug("ActivitySet: " + activitySet.getId() + "; of type: " + activitySet.getType() + "; by: " + activitySet.getCreatedBy());
                LOG.debug("   alreadyCreated: " + alreadyCreated);
            }
            
            if (!alreadyCreated)
            {
                // Populate the ActivitySet
                // Get the ActivitySet type/createdby values (we know these are valid)
                final ActivitySetType ttOM = ActivitySetTypeManager.getInstance(activitySet.getType());
                activitySetOM.setActivitySetType(ttOM);
                if( activitySetCreatedByOM != null ){
                    activitySetOM.setCreatedBy(activitySetCreatedByOM.getUserId());
                }
                else
                {
                	// Anonymous user. better than nothing.
                	try {
						activitySetOM.setCreatedBy(ScarabUserManager.getAnonymousUser().getUserId());
					} catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                }
                activitySetOM.setCreatedDate(activitySet.getCreatedDate().getDate());
                if (activitySetAttachmentOM != null)
                {
                    activitySetAttachmentOM.save();
                    activitySetOM.setAttachment(activitySetAttachmentOM);
                }
                activitySetOM.save();
                if( activitySet.getId() != null){
                    // if id is valid, save for later re-use.
                    activitySetIdMap.put(activitySet.getId(), 
                                         activitySetOM.getPrimaryKey().toString());
                }
            }

            // Determine if this ActivitySet should be marked as the 
            // creation event
            final ActivitySet creationSet = issueOM.getActivitySetRelatedByCreatedTransId();
            if (ActivitySetTypePeer.CREATE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) 
               ||
               (ActivitySetTypePeer.MOVE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) && 
                        (creationSet == null || activitySetOM.getCreatedDate()
                         .before(creationSet.getCreatedDate()))) ) 
            {
                issueOM.setActivitySetRelatedByCreatedTransId(activitySetOM);
                issueOM.save();
            }

/////////////////////////////////////////////////////////////////////////////////  
// Deal with changing user attributes. this code needs to be in this *strange*
// location because we look at the entire activityset in order to determine
// that this is a change user activity set. of course in the future, it would
// be really nice to create an activityset/activiy type that more accurately 
// reflects what type of change this is. so that it is easier to case for. for
// now, we just look at some fingerprints to determine this information. -JSS

            if (activitySet.isChangeUserAttribute())
            {
                final List activities = activitySet.getActivities();
                final XmlActivity activityA = (XmlActivity)activities.get(0);
                final XmlActivity activityB = (XmlActivity)activities.get(1);
                
                final ScarabUser assigneeOM = findUser(activityA.getOldUser());
                final ScarabUser assignerOM = findUser(activityB.getNewUser());

                final Attribute oldAttributeOM = Attribute.getInstance(activityA.getAttribute());

                final AttributeValue oldAttValOM = issueOM.getUserAttributeValue(assigneeOM, oldAttributeOM);
                if (oldAttValOM == null)
                {
                    LOG.error("User '" + assigneeOM.getName() + "' was not previously '" + oldAttributeOM.getName() + "' to the issue!");
                }

                // Get the Attribute associated with the new Activity
                final Attribute newAttributeOM = Attribute.getInstance(activityB.getAttribute());

                issueOM.changeUserAttributeValue(activitySetOM,
                            assigneeOM, 
                            assignerOM, 
                            oldAttValOM,
                            newAttributeOM, null);
                LOG.debug("-------------Updated User AttributeValue------------");
                continue;
            }

/////////////////////////////////////////////////////////////////////////////////  

            // Deal with the activities in the activitySet
            final List activities = activitySet.getActivities();
            LOG.debug("Number of Activities in ActivitySet: " + activities.size());

            final LinkedMap avMap = issueOM.getModuleAttributeValuesMap();
            LOG.debug("Total Module Attribute Values: " + avMap.size());
            for (Iterator itrb = activities.iterator(); itrb.hasNext();)
            {
                final XmlActivity activity = (XmlActivity) itrb.next();
                LOG.debug("Looking at activity id: " + activity.getId());

                // Get the Attribute associated with the Activity
                final Attribute attributeOM = Attribute.getInstance(activity.getAttribute());

                // deal with the activity attachment (if there is one)
                final XmlAttachment activityAttachment = activity.getAttachment();
                Attachment activityAttachmentOM = null;
                if (activityAttachment != null)
                {
                    // look for an existing attachment in the activity
                    // the case is when we have a URL and we create it
                    // and then delete it, the attachment id is still the
                    // same so there is no reason to re-create the attachment
                    // again.
                    final String previousXmlId = activityAttachment.getId();
                    final String previousId = (String)attachmentIdMap.get(previousXmlId);
                    if (previousId == null) 
                    {
                        activityAttachmentOM = createAttachment(issueOM, activityAttachment);
                        activityAttachmentOM.save();
                        attachmentIdMap.put(previousXmlId, activityAttachmentOM.getPrimaryKey().toString());
                        
                        // Special case. After the Attachment object has been 
                        // saved, if the ReconcilePath == true, then assume 
                        // that the fileName is an absolute path to a file and
                        // copy it to the right directory
                        // structure under Scarab's path.
                        if (allowFileAttachments && activityAttachment.getReconcilePath())
                        {
                            try
                            {
                                activityAttachmentOM
                                    .copyFileFromTo(activityAttachment.getFilename(), 
                                                    activityAttachmentOM.getFullPath());
                            } 
                            catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            } 
                            catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                        }
                        LOG.debug("Created Activity Attachment object");
                    }
                    else 
                    {
                        activityAttachmentOM = AttachmentManager
                            .getInstance(previousId);
                        LOG.debug("Found existing Activity Attachment");
                    }
                }
                else
                {
                    LOG.debug("OK- No Attachment in this Activity");
                }

                // deal with null attributes (need to do this before we create the 
                // activity right below because this will create its own activity).
                if (attributeOM.equals(nullAttribute))
                {
                    // add any dependency activities to a list for later processing
                    if (isDependencyActivity(activity))
                    {
                        if (!isDuplicateDependency(activity))
                        {
                            final Object[] obj = {activitySetOM, activity, activityAttachmentOM};
                            allDependencies.add(obj);
                            dependActivitySetId.add(activity.getDependency());
                            LOG.debug("-------------Stored Dependency # " 
                                    + allDependencies.size() + '[' + activity.getDependency() + ']');
                            continue;
                        }
                    }
                    else
                    {
                        // create the activity record.
                        ActivityManager.createTextActivity(issueOM, nullAttribute, activitySetOM, 
                                    ActivityType.getActivityType(activity.getActivityType()), activity.getDescription(), activityAttachmentOM, 
                                    activity.getOldValue(), activity.getNewValue());
        
                        LOG.debug("-------------Saved Null Attribute-------------");
                        continue;
                    }
                }

                // create the activityOM
                createActivity(activity, module, 
                                            issueOM, attributeOM, activitySetOM);

                // check to see if this is a new activity or an update activity
                AttributeValue avalOM = null;
                for (Iterator moduleAttributeValueItr = avMap.mapIterator(); 
                     moduleAttributeValueItr.hasNext() && avalOM == null;)
                {
                    final AttributeValue testAvalOM = (AttributeValue)
                        avMap.get(moduleAttributeValueItr.next());
                    final Attribute avalAttributeOM = testAvalOM.getAttribute();

                    LOG.debug("Checking Attribute match: " + avalAttributeOM.getName() + 
                              " against: " + attributeOM.getName());
                    if (avalAttributeOM.equals(attributeOM))
                    {
                        avalOM = testAvalOM;
                    }
                }

                if (avalOM != null) 
                {
                    final Attribute avalAttributeOM = avalOM.getAttribute();
                    LOG.debug("Attributes match!");
                    AttributeValue avalOM2 = null;
                    if (!activity.isNewActivity())
                    {
                        LOG.debug("Activity is not new.");
                        avalOM2 = AttributeValue.getNewInstance(
                            avalAttributeOM.getAttributeId(), 
                            avalOM.getIssue());
                        avalOM2.setProperties(avalOM);
                    }

                    if (avalAttributeOM.isOptionAttribute())
                    {
                        LOG.debug("We have an Option Attribute: " + 
                                  avalAttributeOM.getName());
                        final AttributeOption newAttributeOptionOM = 
                                AttributeOptionManager.getInstance(
                                         attributeOM, activity.getNewOption(),
                                         issueOM.getModule(),
                                         issueOM.getIssueType());
                        if (activity.isNewActivity())
                        {
                            if (newAttributeOptionOM != null)
                            {
                                avalOM.setOptionId(newAttributeOptionOM.getOptionId());
                                avalOM.startActivitySet(activitySetOM);
                                avalOM.setAttribute(attributeOM);
                                avalOM.save();
                                LOG.debug("-------------Saved Attribute Value-------------");
                            }
                            else
                            {
                                LOG.warn("NewAttributeOptionOM is null for " +
                                         activity.getNewOption());
                            }
                        }
                        else if(newAttributeOptionOM != null)
                        {
                            avalOM2.setOptionId(newAttributeOptionOM.getOptionId());
                            final HashMap map = new HashMap();
                            map.put(avalOM.getAttributeId(), avalOM2);
                            issueOM.setAttributeValues(activitySetOM, map, null, activitySetCreatedByOM);
                            LOG.debug("-------------Saved Option Attribute Change-------------");
                        }
                    }
                    else if (avalAttributeOM.isUserAttribute())
                    {
                        LOG.debug("We have a User Attribute: " 
                                  + avalAttributeOM.getName());
                        if (activity.isNewActivity())
                        {
                            // Don't need to pass in the attachment because
                            // it is already in the activitySetOM.
                            // If we can't get an assignee new-user, then 
                            // use the activity set creator as assignee.
                            ScarabUser assigneeOM = findUser(activity.getNewUser());
                            assigneeOM = (assigneeOM != null)
                                ? assigneeOM: activitySetCreatedByOM;
                            if( assigneeOM != null ){
                                issueOM.assignUser(activitySetOM, 
                                    assigneeOM, null, avalAttributeOM, null);
                            }
                            LOG.debug("-------------Saved User Assign-------------");
                        }
                        else if (activity.isRemoveUserActivity())
                        {
                            // remove a user activity
                            final ScarabUser oldUserOM = findUser(activity.getOldUser());
                            // need to reset the aval because the current one
                            // is marked as new for some reason which causes an
                            // insert and that isn't the right behavior here 
                            // (we want an update)
                            avalOM = null;
                            for (Iterator i = issueOM.getAttributeValues(
                                 avalAttributeOM).iterator(); 
                                 i.hasNext() && avalOM == null;) 
                            {
                                final AttributeValue av = (AttributeValue)i.next();
                                if (oldUserOM.getUserId().equals(av.getUserId())) 
                                {
                                    avalOM = av;
                                }
                            }

                            if (avalOM == null) 
                            {
                                if (LOG.isDebugEnabled()) 
                                {
                                    LOG.debug("Could not find previous AttributeValue assigning " +
                                        (oldUserOM == null ? "NULL" : 
                                        oldUserOM.getUserName()) + 
                                        " to attribute " + 
                                              avalAttributeOM.getName());
                                }                                
                            }
                            else 
                            {
                                // don't need to pass in the attachment because
                                // it is already in the activitySetOM
                                issueOM.deleteUser(activitySetOM, oldUserOM, 
                                    activitySetCreatedByOM, avalOM, null);
                                LOG.debug("-------------Saved User Remove-------------");
                            }
                        }
                    }
                    else if (avalAttributeOM.isTextAttribute() || avalAttributeOM.isIntegerAttribute())
                    {
                        LOG.debug("We have a Text Attribute: " + avalAttributeOM.getName());

                        avalOM.startActivitySet(activitySetOM);
                        avalOM.setAttribute(attributeOM);

                        if (activity.isNewActivity())
                        {
                            avalOM.setValue(activity.getNewValue());
                        }
                        else if (!activity.getNewValue()
                                .equals(avalOM.getValue()))
                        {
                            avalOM2.setValue(activity.getNewValue());
                            avalOM.setProperties(avalOM2);
                        }
                        
                        avalOM.save();
                        LOG.debug("-------------Saved Attribute Value-------------");
                    }
                }
                issueOM.save();
                LOG.debug("-------------Saved Issue-------------");
            }
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Activity createActivity(final XmlActivity activity,  
                                         final XmlModule module,
                                         final Issue issueOM, 
                                         final Attribute attributeOM,
                                         final ActivitySet activitySetOM)
        throws TorqueException, ParseException, ScarabException
    {
        Activity activityOM = null;
        if (getImportTypeCode() == UPDATE_SAME_DB)
        {
            try
            {
                activityOM = ActivityManager.getInstance(activity.getId());
            }
            catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
        }
        else
        {
            activityOM = ActivityManager.getInstance();
        }

        activityOM.setIssue(issueOM);
        activityOM.setAttribute(attributeOM);
        activityOM.setActivityType(ActivityType.OTHER.getCode());
        activityOM.setActivitySet(activitySetOM);
        if (activity.getEndDate() != null)
        {
            activityOM.setEndDate(activity.getEndDate().getDate());
        }

        // Set the attachment for the activity
        Attachment newAttachmentOM = null;
        if (activity.getAttachment() != null)
        {
            newAttachmentOM = createAttachment(issueOM, activity.getAttachment());
            newAttachmentOM.save();
            activityOM.setAttachment(newAttachmentOM);
        }

        LOG.debug("Created New Activity");
        return activityOM;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Attachment createAttachment(final Issue issueOM, 
            final XmlAttachment attachment)
        throws TorqueException, ScarabException, ParseException
    {
        final Attachment attachmentOM = AttachmentManager.getInstance();
        attachmentOM.setIssue(issueOM);
        final AttachmentType type = AttachmentType.getInstance(attachment.getType());
        if (allowFileAttachments || !Attachment.FILE__PK.equals(type.getAttachmentTypeId())) 
        {
            attachmentOM.setName(attachment.getName());
            attachmentOM.setAttachmentType(type);
            attachmentOM.setMimeType(null != attachment.getMimetype()
                    ? attachment.getMimetype()
                    : ComponentLocator.getMimeTypeService().getContentType(attachment.getFilename(), null));
            attachmentOM.setFileName(attachment.getFilename());        
            attachmentOM.setData(attachment.getData());
        }
        else 
        {
            // add a comment that the file will not be imported.  An alternative would be
            // to skip the activity altogether, but we will then need to check that there 
            // are other activities or we need to completely ignore the ActivitySet
            attachmentOM.setName("comment");
            attachmentOM.setTypeId(Attachment.COMMENT__PK);
            attachmentOM.setMimeType("text/plain");
            String text = "File, " + attachment.getFilename() + 
                ", was not imported. The old description follows:\n\n" + attachment.getName();
            final String data = attachment.getData();  // this should be null, but just in case
            if (data != null) 
            {
                text += "\n\n" + data;
            }
            attachmentOM.setData(text);
        }
        
        attachmentOM.setCreatedDate(attachment.getCreatedDate().getDate());
        final ModifiedDate modifiedDate = attachment.getModifiedDate();
        if (modifiedDate != null)
        {
            attachmentOM.setModifiedDate(modifiedDate.getDate());
        }
        final ScarabUser creUser = findUser(attachment.getCreatedBy());
        if (creUser != null)
        {
            attachmentOM.setCreatedBy(creUser.getUserId());
        }

        final String modifiedBy = attachment.getModifiedBy();
        if (modifiedBy != null)
        {
            final ScarabUser modUserOM = findUser(attachment.getModifiedBy());
            if (modUserOM != null)
            {
                attachmentOM.setModifiedBy(modUserOM.getUserId());
            }
        }

        attachmentOM.setDeleted(attachment.getDeleted());
        return attachmentOM;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private ScarabUser findUser(final String userStr) 
        throws TorqueException,ScarabException
    {
        
        ScarabUser user = ScarabUserManager.getInstance(userStr);
        if (user == null && userStr != null && userStr.indexOf("@") <0 )
        {
            LOG.debug("user specified possibly by email address: "+userStr);
            // maybe it's an email not a username
            user = ScarabUserManager.getInstanceByEmail(userStr);
            LOG.debug("found "+user);
        }
        return user;        
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Module getModuleForIssue(final XmlModule module, final XmlIssue issue)
        throws TorqueException, ScarabException
    {
        
        if(issue.hasModuleCode() && !issue.getModuleCode().equals(module.getCode()) && !allowGlobalImport){
            throw new ScarabException(
                    new L10NKey("Lacking permission to cross-module import. Contact your administor. <localize me>"));
        }
        
        return issue.hasModuleCode()
                ? ModuleManager.getInstance(module.getDomain(),
                                            null,issue.getModuleCode())
                : ModuleManager.getInstance(module.getDomain(),
                                            module.getName(), module.getCode());
     }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public void init()
        throws ScarabException,MalformedURLException,IOException
    {
        TurbineInitialization.setTurbineResources(getTurbineResources());
        TurbineInitialization.setUp(getConfigDir().getAbsolutePath(), 
            getConfigFile());
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public void execute() 
        throws ScarabException
    {
        runImport(getXmlFile());
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public Collection runImport(final File importFile)
        throws ScarabException
    {
        return runImport(importFile, (Module) null);
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public Collection runImport(final File importFile, final Module currentModule)
        throws ScarabException
    {
        return runImport(importFile.getAbsolutePath(), importFile,
                         currentModule, SCARAB);
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public Collection runImport(final FileItem importFile)
        throws ScarabException
    {
        return runImport(importFile, (Module) null, SCARAB);
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public Collection runImport(final FileItem importFile, 
            final Module currentModule,
            final ImportType type)
        throws ScarabException
    {
        return runImport(importFile.getName(), importFile, currentModule, type);
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected Collection runImport(final String filePath, 
            final Object input,
            final Module currentModule,
            final ImportType type)
        throws ScarabException
    {
        
        final String msg = "Importing issues from XML '" + filePath + '\'';
        LOG.debug(msg);
        try
        {
            // Disable workflow and set file attachment flag
            WorkflowFactory.setForceUseDefault(true);
            
            final Reader is = getScarabFormattedReader(input,type,currentModule);
            
            final BeanReader reader = createScarabIssuesBeanReader();
            validate(filePath, is, reader, currentModule);

            if (importErrors == null || importErrors.isEmpty())
            {
                // Reget the input stream.
                si = insert(filePath, getScarabFormattedReader(input,type,currentModule), reader);
            }
        }
        catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
        finally
        {
            // Re-enable workflow.
            WorkflowFactory.setForceUseDefault(false);
        }

        return importErrors;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected ScarabIssues insert(
            final String name, 
            final Reader is, 
            final BeanReader reader)
        throws ParserConfigurationException,SAXException,IOException,ScarabException, TorqueException
    {
        setValidationMode(reader, false);
        final ScarabIssues si = (ScarabIssues)reader.parse(is);
        si.doHandleDependencies();
        LOG.debug("Successfully imported " + name + '!');
        return si;
    }
              
// in java/org/tigris/scarab/util/TurbineInitialization.java
public static void setUp(final String configDir, final String configFile)
        throws ScarabException,MalformedURLException,IOException
    {
        if (configDir == null || configFile == null)
        {
            System.err.println("config.dir System property was not defined");
            throw new ScarabException (new L10NKey("configDir or configFile was null")); // FIXME localise
        }

        // set this so that the proper substitution will happen in the
        // configFile
        System.getProperties().setProperty("configDir", configDir);

        initTurbine(configDir);
        
        final InputStream is = new File(configDir + configFile).toURL()
            .openStream();
        final Properties props = new Properties();
        try
        {
            props.load(is);
            // init Log4J
            PropertyConfigurator.configure(props);
        }
        catch (Exception e)
        {
            System.err.println("Can't read the properties file (" + 
                configDir + configFile + "). ");
        }
    }
(Lib) TorqueException 42 
              
// in java/org/tigris/scarab/om/AttributeValue.java
public static synchronized AttributeValue getNewInstance(
        Attribute attribute, Issue issue) throws TorqueException
    {
        AttributeValue attv = null;
        try
        {
            String className = attribute
                .getAttributeType().getJavaClassName();
            attv = (AttributeValue)
                Class.forName(className).newInstance();
            attv.setAttribute(attribute);
            attv.setIssue(issue);
    
            attv.init();
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        return attv;
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void save(Connection dbcon)
        throws TorqueException
    {
        if (isModified() && !getAttribute().isUserAttribute())
        {
            try
            {
                checkActivitySet(L10NKeySet.ExceptionCanNotSaveAttributeValue);
            }
            catch (Exception e)
            {
                throw new TorqueException(e);
            }
            if (saveActivity == null)
            {            
                if (getDeleted())
                {
                    saveActivity = ActivityManager
                        .create(getIssue(), getAttribute(), activitySet, 
                                ActivityType.ATTRIBUTE_CHANGED, null, null, getNumericValue(), ScarabConstants.INTEGER_0,
                                getUserId(), null, getOptionId(), null, 
                                getValue(), null, dbcon);
                }
                else
                {
                    saveActivity = ActivityManager
                        .create(getIssue(), getAttribute(), activitySet, 
                                ActivityType.ATTRIBUTE_CHANGED, null, null, oldNumericValue, getNumericValue(),
                                oldUserId, getUserId(), oldOptionId, getOptionId(), 
                                oldValue, getValue(), dbcon);
                }
            }
        }
        super.save(dbcon);
        if (chainedValue != null) 
        {
            chainedValue.save(dbcon);
        }
        endActivitySet();
    }
              
// in java/org/tigris/scarab/om/Query.java
public void setModule(Module me)
        throws TorqueException
    {
        if (me == null) 
        {
            setModuleId((Integer)null);            
        }
        else 
        {
            Integer id = me.getModuleId();
            if (id == null) 
            {
                throw new TorqueException("Modules must be saved prior to " +
                    "being associated with other objects."); //EXCEPTION
            }
            setModuleId(id);
        }        
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity create(Issue issue, Attribute attribute,
                       ActivitySet activitySet, ActivityType type, 
                       String description, Attachment attachment, Depend depend,
                       Integer oldNumericValue, Integer newNumericValue,
                       Integer oldUserId, Integer newUserId,
                       Integer oldOptionId, Integer newOptionId,
                       String oldTextValue, String newTextValue, 
                       Connection dbCon)
         throws TorqueException
    {
        Activity activity = ActivityManager.getInstance();
        activity.setIssue(issue);
        if (attribute == null)
        {
            attribute = Attribute.getInstance(0);
        }
        activity.setAttribute(attribute);
        activity.setActivitySet(activitySet);
        activity.setOldNumericValue(oldNumericValue);
        activity.setNewNumericValue(newNumericValue);
        activity.setOldUserId(oldUserId);
        activity.setNewUserId(newUserId);
        activity.setOldOptionId(oldOptionId);
        activity.setNewOptionId(newOptionId);
        activity.setOldValue(oldTextValue);
        activity.setNewValue(newTextValue);
        activity.setDepend(depend);
        activity.setDescription(description);
        activity.setActivityType(type!=null?type.getCode():null);
        if (attachment != null)
        {
            activity.setAttachment(attachment);
        }
        if (dbCon == null) 
        {
            try
            {
                activity.save();
            }
            catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        else 
        {
            activity.save(dbCon);
        }
        // Make sure new activity is added to activity cache
        try
        {
            issue.addActivity(activity);
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        return activity;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void save(Connection con) throws TorqueException
    {
        if (isModified())
        {
            if (isNew())
            {
                super.save(con);
            }
            else
            { 
                RIssueTypeAttribute ria = null;
                try
                {
                    ria = getIssueType().getRIssueTypeAttribute(getAttribute());
                    if ((ria != null && ria.getLocked()))
                    {
                    throw new TorqueException(getAttribute().getName() + " is locked"); //EXCEPTION
                    }
                    else
                    {
                        super.save(con);
                    }
                }
                catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public void save(Connection con) throws TorqueException
    {
        if (isModified())
        {
            if (isNew())
            {
                super.save(con);
            }
            else
            {
                Attribute attr = getAttributeOption().getAttribute();
                RIssueTypeAttribute ria = null;
                try
                {
                    ria = getIssueType().getRIssueTypeAttribute(attr);
                    if (ria != null && ria.getLocked())
                    {
                        throw new TorqueException(attr.getName() + "is locked"); //EXCEPTION
                    }
                    else
                    {
                        super.save(con);
                    }
                }
                catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
private void addAncestors(AttributeOption option)
        throws TorqueException, Exception
    {
        if (!ROOT_ID.equals(option.getParent().getOptionId()))
        {
            if (ancestors.contains(option.getParent()))
            {
                throw new TorqueException("Tried to add a recursive parent-child " +
                                    "attribute option relationship."); //EXCEPTION
            }
            else
            { 
                addAncestors(option.getParent());
            }
        }
        ancestors.add(option.getOptionId());
    }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(Integer moduleId, Integer userId, String activityType) throws ScarabException
    {
        NotificationRule rule = null;
        
        int managerId = NotificationManagerFactory.getInstance().getManagerId();
        Criteria crit = new Criteria();
        crit.add(NotificationRulePeer.USER_ID, userId);
        crit.add(NotificationRulePeer.MODULE_ID, moduleId);
        crit.add(NotificationRulePeer.ACTIVITY_TYPE, activityType);
        crit.add(NotificationRulePeer.MANAGER_ID, managerId);
                
        try
        {
            List<NotificationRule> ruleSet = (List<NotificationRule>)NotificationRulePeer.doSelect(crit);     
            if(ruleSet == null || ruleSet.size()==0)
            {

                rule = NotificationRule.createDefaultRule( 
                       moduleId, 
                       userId,
                       managerId,
                       activityType);
            }
            else if (ruleSet.size() > 1)
            {
                String msg = "Database inxonsistency:"
                           + " Expected at most one key matching (user_id,module_id,activity_type,manager_id) = "
                           + ")" + userId + "," + moduleId + "," + activityType + "," + managerId + ")";
                throw new TorqueException(msg,new Throwable());
            }
            else
            {
                rule = ruleSet.get(0);
            }
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }

        return rule;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public AttributeOption getAttributeOption(String optionID)
        throws TorqueException
    {
        if (optionID == null || optionID.length() == 0)
        {
            throw new TorqueException("optionId is empty"); //EXCEPTION
        }
        return getAttributeOption(new Integer(optionID));
    }
              
// in java/org/tigris/scarab/om/Issue.java
public static List parseIssueList(final Module module, final String theList)
        throws TorqueException, DataSetException
    {
        final String[] issues = StringUtils.split(theList, ",");
        final List results = new ArrayList();
        for (int i = 0; i < issues.length; i++)
        {
            if (issues[i].indexOf('*') != -1)
            {
                // Probably better to use more Torque here, but this
                // is definitely going to be faster and more
                // efficient.
                final String sql = "SELECT CONCAT(" + IssuePeer.ID_PREFIX + ',' +
                    IssuePeer.ID_COUNT + ") FROM " + IssuePeer.TABLE_NAME +
                    " WHERE " + IssuePeer.ID_PREFIX + " = '" +
                    module.getCode() + '\'';
                final List records = BasePeer.executeQuery(sql);
                for (Iterator j = records.iterator(); j.hasNext();)
                {
                    final Record rec = (Record)j.next();
                    results.add(rec.getValue(1).asString());
                }
            }
            // check for a -
            else if (issues[i].indexOf('-') == -1)
            {
                // Make sure user is not trying to access issues from another
                // module.
                final FederatedId fid = createFederatedId(module, issues[i]);
                if (!fid.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    final String[] args = { fid.getPrefix(), module.getCode() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixNotForModule", args)); //EXCEPTION
                }
                results.add(issues[i]);
            }
            else
            {
                final String[] issue = StringUtils.split(issues[i], "-");
                if (issue.length != 2)
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDRangeNotValid", issues[i])); //EXCEPTION
                }
                FederatedId fidStart = createFederatedId(module, issue[0]);
                FederatedId fidStop = createFederatedId(module, issue[1]);
                if (!fidStart.getPrefix().equalsIgnoreCase(module.getCode()) ||
                    !fidStop.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesNotForModule",
                                         module.getCode())); //EXCEPTION
                }
                else if (!fidStart.getPrefix()
                         .equalsIgnoreCase(fidStop.getPrefix()))
                {
                    final String[] args = { fidStart.getPrefix(),
                                      fidStop.getPrefix() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesDoNotMatch", args)); //EXCEPTION
                }
                else if (fidStart.getCount() > fidStop.getCount())
                {
                    FederatedId swap = fidStart;
                    fidStart = fidStop;
                    fidStop = swap;
                }

                for (int j = fidStart.getCount(); j <= fidStop.getCount();j++)
                {
                    results.add(fidStart.getPrefix() + j);
                }
            }
        }
        return results;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private static FederatedId createFederatedId(Module module, String id)
        throws TorqueException
    {
        FederatedId fid = null;
        try
        {
            fid = new FederatedId(id.trim());
            if (fid.getPrefix() == null || fid.getPrefix().length() == 0)
            {
                fid.setPrefix(module.getCode());
            }
        }
        catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
        return fid;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/Issue.java
protected Set<ScarabUser> getUsersToEmail(String action, Issue issue, Set<ScarabUser> users)
        throws TorqueException
    {
        if (users == null)
        {
            users = new HashSet<ScarabUser>(1);
        }

        Module module = getModule();

        ScarabUser createdBy = issue.getCreatedBy();
        if (createdBy != null && !users.contains(createdBy) &&
            AttributePeer.EMAIL_TO.equals(action) &&
               createdBy.hasPermission(ScarabSecurity.ISSUE__ENTER, module))
        {
            users.add(createdBy);
        }

        Criteria crit = new Criteria()
            .add(AttributeValuePeer.ISSUE_ID, issue.getIssueId())
            .addJoin(AttributeValuePeer.ATTRIBUTE_ID,
                     AttributePeer.ATTRIBUTE_ID)
            .add(AttributePeer.ACTION, action)
            .add(RModuleAttributePeer.MODULE_ID, getModuleId())
            .add(RModuleAttributePeer.ISSUE_TYPE_ID, getTypeId())
            .add(AttributeValuePeer.DELETED, 0)
            .add(RModuleAttributePeer.ACTIVE, true)
            .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                     AttributeValuePeer.ATTRIBUTE_ID);
        List userAttVals = AttributeValuePeer.doSelect(crit);
        for (Iterator i = userAttVals.iterator(); i.hasNext(); )
        {
            AttributeValue attVal = (AttributeValue) i.next();
            try
            {
                ScarabUser su = ScarabUserManager
                    .getInstance(attVal.getUserId());
                if (!users.contains(su)
                    && su.hasPermission(attVal.getAttribute().getPermission(),
                                        module))
                {
                    users.add(su);
                }
            }
            catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
        }
        return users;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Set<ScarabUser> getAllUsersToEmail(String action) throws TorqueException
    {
        Set<ScarabUser> result = null;
        Object obj = ScarabCache.get(this, GET_ALL_USERS_TO_EMAIL, action); 
        if (obj == null) 
        {        
            Set<ScarabUser> users = new HashSet<ScarabUser>();
            try
            {
                users = getUsersToEmail(action, this, users);
                List children = getChildren();
                for (int i=0;i<children.size();i++)
                {
                    Issue depIssue = IssueManager.getInstance
                        (((Depend) children.get(i)).getObserverId());
                    users = getUsersToEmail(action, depIssue, users);
                }
                result = users;
            }
            catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            ScarabCache.put(result, this, GET_ALL_USERS_TO_EMAIL, action);
        }
        else 
        {
            result = (Set)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void addActivity(Activity activity) throws TorqueException  
    {
        List activityList = null;
        try
        {
            activityList = getActivity(true);
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        super.addActivity(activity);
        if (!activityList.contains(activity))
        {
            activityList.add(activity);
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void save(Connection dbCon)
        throws TorqueException
    {
        Module module = getModule();
        if (!module.allowsIssues() || (isNew() && !module.allowsNewIssues())) 
        {
            throw new UnsupportedOperationException(module.getName() + 
                " does not allow issues."); //EXCEPTION
        }
        
        // remove unset AttributeValues before saving
        List attValues = getAttributeValues();
        // reverse order since removing from list
        for (int i=attValues.size()-1; i>=0; i--) 
        {
            AttributeValue attVal = (AttributeValue) attValues.get(i);
            if (!attVal.isSet()) 
            {
                attValues.remove(i);
            }
        }

        if (isNew())
        {
            // set the issue id
            setIdDomain(module.getScarabInstanceId());
            setIdPrefix(module.getCode());

            // for an enter issue template, do not give issue id
            // set id count to -1 so does not show up as an issue
            if (isTemplate())
            { 
                setIdCount(-1);
            }
            else
            {
                try
                {
                    final int suggestedID = getIdCount();
                    if (suggestedID != 0) {
                        // Force the next available issue ID to be the
                        // nominated value, if not out of sequence.
                        // TODO: assert that this issue doesn't already exist
                        // In this case, just skip the next action.
                        setNextIssueId(dbCon, suggestedID);
                    }
                    
                    // Set the ID to the next available value.
                    setIdCount(getNextIssueId(dbCon));
                }
                catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        if(  getActivitySetRelatedByLastTransId()==null
           ||getActivitySetRelatedByCreatedTransId()==null)
        {
            throw new RuntimeException("Created or Last ActivitySet must not be null.");
        }
        super.save(dbCon);
    }
              
// in java/org/tigris/scarab/om/Issue.java
private void saveIdTableKey(final Connection dbCon, final int nextID)
        throws TorqueException
    {
        int id = 0;
        final DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        final IDBroker idbroker = dbMap.getIDBroker();
        final String idTable = IDBroker.TABLE_NAME.substring(0, 
        IDBroker.TABLE_NAME.indexOf('.'));
        try
        {
            id = idbroker.getIdAsInt(dbCon, idTable);
        }
        catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }

        final String key = getIdTableKey();

        // FIXME: UGLY! IDBroker doesn't have a Peer yet.
        final String sql = "insert into " + idTable 
         + " (ID_TABLE_ID,TABLE_NAME,NEXT_ID,QUANTITY) "
         + " VALUES (" + id + ",'" + key + "'," + nextID + ",1)" ;
        BasePeer.executeStatement(sql, dbCon);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setInitialAttributeValues(ActivitySet activitySet, 
            Attachment attachment, 
            final HashMap newValues, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check new values for workflow
        final String msg = doCheckInitialAttributeValueWorkflow(newValues, user);
        if (msg != null)
        {
            throw new TorqueException(msg); //EXCEPTION
        }
        
        if (activitySet == null)
        {
            // Save activitySet record
            activitySet = ActivitySetManager
                .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
            activitySet.save();
        }
        setActivitySetRelatedByCreatedTransId(activitySet);

        // enter the values into the activitySet
        final LinkedMap avMap = getModuleAttributeValuesMap(); 
        final MapIterator iter = avMap.mapIterator();
        while (iter.hasNext())
        {
            final AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            try
            {
                aval.startActivitySet(activitySet);
            }
            catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
        }        
        this.save();

        // create initial issue creation activity
        ActivityManager.createReportIssueActivity(this, activitySet,  
                Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueCreated"));

        // this needs to be done after the issue is created.
        // check to make sure the attachment has data before submitting it.
        final String attachmentData = attachment.getData();
        if (attachmentData != null &&
            attachmentData.length() > 0)
        {
            attachment = AttachmentManager.getReason(attachment, this, user);
            activitySet.setAttachment(attachment);
        }
        activitySet.save();
        
        // need to clear the cache since this is after the 
        // issue is saved. for some reason, things don't
        // show up properly right away.
        ScarabCache.clear();
        
        index();
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setPasswordExpire(Calendar expire)
        throws TorqueException
    {
        Integer userid = getUserId();
        if (userid == null)
        {
            throw new TorqueException("Userid cannot be null"); //EXCEPTION
        }
        UserPreference up = UserPreferenceManager.getInstance(getUserId());
        if (expire == null)
        {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + 10);
            up.setPasswordExpire(cal.getTime());
        }
        else
        {
            up.setPasswordExpire(expire.getTime());
        }
        up.save();
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public void save(Connection dbCon)
        throws TorqueException
    {
        if (getIssue().isNew()) 
        {
            throw new TorqueException("Cannot save an attachment before saving"
                                      + " the issue to which it is attached."); //EXCEPTION
        }
        // It would be better (from an oo perspective) to do this whenever 
        // setData is called, but we can't be sure the typeId will be 
        // set prior to setting the url, so we will do the check here.
        setData(doMakeURLFromData());

        // need to handle the case where we don't want to be smart
        // and just set the dates to be whatever we want them
        // to be (xml import!).
        if (isNew() && (getCreatedDate() == null && getModifiedDate() == null))
        {
            Date now = new Date();
            setCreatedDate(now);
            setModifiedDate(now);
        }
        else if (isModified()) 
        {
            setModifiedDate(new Date());
        }
        
        super.save(dbCon);
        
        try
        {
            FileItem file = getFile();
            if (file != null) 
            {        
                File uploadFile = 
                    new File(getRepositoryDirectory(),getRelativePath());
                File parent = uploadFile.getParentFile();
                if (!parent.exists()) 
                {
                    mkdirs(parent);
                }                
                file.write(uploadFile);
            }
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/om/DependTypeManager.java
public static DependType getInstance(String dependTypeName)
        throws TorqueException
    {
        DependType result = null;
        Object obj = ScarabCache.get(DEPENDTYPE, FIND_DEPENDTYPE_BY_NAME, 
                                     dependTypeName); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(DependTypePeer.DEPEND_TYPE_NAME, dependTypeName);
            List dependTypes = DependTypePeer.doSelect(crit);
            if (dependTypes == null || dependTypes.size() == 0)
            {
                throw new TorqueException("Invalid issue depend type: " + 
                                    dependTypeName); //EXCEPTION
            }
            result = (DependType)dependTypes.get(0);
            ScarabCache.put(result, DEPENDTYPE, FIND_DEPENDTYPE_BY_NAME, 
                            dependTypeName);
        }
        else 
        {
            result = (DependType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static Class getOMClass(Record record, int offset) 
        throws TorqueException
    {
        Class c = null;
        try
        {
            Integer attId = new Integer(record.getValue(offset-1 + 3)
                                            .asString());
            Attribute attribute = AttributeManager.getInstance(attId);
            String className = attribute.getAttributeType().getJavaClassName();

            c = (Class)classMap.get(className);
            if (c == null) 
            {
                c = Class.forName(className);
                classMap.put(className, c);            
            }
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        
        return c;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if ( id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void deleteAttribute(final Attribute attribute, 
            final ScarabUser user,
            final Module module)
         throws TorqueException, ScarabException
    {                
        String permission = null;
        if (isGlobal())
        {
            permission = (ScarabSecurity.DOMAIN__EDIT);
        }
        else
        {
            permission = (ScarabSecurity.MODULE__CONFIGURE);
        }
        if (user.hasPermission(permission, module))
        {
            final IssueType issueType = getIssueType();
            final IssueType template = IssueTypeManager.getInstance
                                 (issueType.getTemplateId());
            boolean success = true;

            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
            if (isGlobal())
            {
                // This is a global attribute group
                // Remove attribute - issue type mapping
                final List rias = issueType.getRIssueTypeAttributes
                                     (false, AttributePeer.NON_USER);
                if (ria != null) 
                {
                    ria.delete();                    
                }
                if (rias != null) 
                {
                    rias.remove(ria);        
                }
            }
            else
            {
                // Check if attribute is locked
                if (ria != null && ria.getLocked())
                {
                    success = false;
                    throw new TorqueException(attribute.getName() + "is locked"); //EXCEPTION
                }
                else
                {
                    // Remove attribute - module mapping
                    final List rmas = module.getRModuleAttributes(issueType, false,
                                                            AttributePeer.NON_USER);    
                    final RModuleAttribute rma = module
                        .getRModuleAttribute(attribute, issueType);
                    if(rma != null)rma.delete();
                    WorkflowFactory.getInstance().deleteWorkflowsForAttribute
                                                  (attribute, module, issueType);
                    if(rma != null)rmas.remove(rma);

                    // Remove attribute - module mapping from template type
                    final RModuleAttribute rma2 = module
                                   .getRModuleAttribute(attribute, template);
                    if(rma2 != null)
                    {
                        rma2.delete();
                        rmas.remove(rma2);
                    }
                }
            }

            if (success)
            {
                // Remove attribute - group mapping
                final RAttributeAttributeGroup raag = 
                    getRAttributeAttributeGroup(attribute);
                raag.delete();

                if (attribute.isOptionAttribute())
                {
                    if (isGlobal())
                    { 
                        // global attributeGroup; remove issuetype-option maps
                        final List rios = issueType.getRIssueTypeOptions(attribute);
                        if (rios != null)
                        {
                            for (int i = 0; i<rios.size();i++)
                            {
                                ((RIssueTypeOption) rios.get(i))
                                    .delete(user, module);
                            }
                        }
                    }
                    else
                    {
                        // Remove module-option mapping
                        final List rmos = module.getRModuleOptions(attribute, issueType);
                        if (rmos != null)
                        {
                            rmos.addAll(module.getRModuleOptions(attribute, template));
                            for (int j = 0; j<rmos.size();j++)
                            {
                                final RModuleOption rmo = (RModuleOption)rmos.get(j);
                                 // rmo's may be inherited by the parent module.
                                 // don't delete unless they are directly associated
                                 // with this module.  Will know by the first one.
                                 if (rmo.getModuleId().equals(module.getModuleId())) 
                                 {
                                     rmo.delete();
                                 }
                                 else 
                                 {
                                     break;
                                 } 
                             }
                         }
                     }
                 }
             }
         }
         else
         {
             throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
         }            
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean isVisible4User(ScarabUser user) throws TorqueException
    {
        Role role = this.getRole4View();
        boolean bRdo = false;
        if (role == null)
        {
            bRdo = true;
        }
        else
        {
            if (user != null)
            {
                try
                {
	            AccessControlList acl = TurbineSecurity.getACL(user);
	            GroupSet allGroups = TurbineSecurity.getAllGroups();
                    Group group = allGroups.getGroup(user.getCurrentModule().getName());
                    bRdo = acl.hasRole(role, group);
                }
                catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
                catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
            }
        }
        return bRdo;	
    }
              
// in java/org/tigris/scarab/om/ModuleManager.java
protected Module getInstanceImpl(final String moduleDomain, 
                                     final String moduleRealName, 
                                     final String moduleCode)
        throws TorqueException
    {
        final Criteria crit = new Criteria();
        if( moduleDomain != null )
        {
            crit.add(ScarabModulePeer.DOMAIN, moduleDomain);
        }
        if( moduleRealName != null )
        {
            crit.add(ScarabModulePeer.MODULE_NAME, moduleRealName);
        }
        if( moduleCode != null )
        {
            crit.add(ScarabModulePeer.MODULE_CODE, moduleCode);
        }
        final List result = ScarabModulePeer.doSelect(crit);
        if (result.size() != 1)
        {
            throw new TorqueException ("Selected: " + result.size() + 
                " rows. Expected 1."); //EXCEPTION
        }
        return (Module) result.get(0);
    }
              
// in java/org/tigris/scarab/om/ModuleManager.java
public static List getInstancesFromIssueList(List issues)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        

        List modules = new ArrayList();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            if (issue != null)
            {
                Module module = issue.getModule();
                if (module != null && !modules.contains(module)) 
                {
                    modules.add(module);
                }
            }
            else
            {
                throw new TorqueException("Null issue in list is not allowed."); //EXCEPTION
            }
        }
        return modules;
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void delete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        int nObjectType = data.getParameters().getInt("obj_type");
        Criteria crit = new Criteria();
        switch (nObjectType)
        {
            case ScarabConstants.TRANSITION_OBJECT:
            	Integer tranId = data.getParameters().getInteger("transition_id");
            	crit.add(ConditionPeer.TRANSITION_ID, tranId);
            	TransitionManager.getMethodResult().remove(TransitionManager.getInstance(tranId), TransitionManager.GET_CONDITIONS);
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, 0);
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, 0);
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
        		crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, data.getParameters().getInt("module_id"));
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, data.getParameters().getInt("issueTypeId"));
        		break;
            case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabRequestTool scarabR = getScarabRequestTool(context);
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.deleteConditions(user, module);
                return;
        }
        ConditionPeer.doDelete(crit);
    	ConditionManager.clear();
    	TransitionManager.clear();
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void updateObject(RunData data, TemplateContext context, Integer aConditions[]) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Integer operator = data.getParameters().getInteger("combineWith");
        switch (data.getParameters().getInt("obj_type"))
        {
            case ScarabConstants.TRANSITION_OBJECT:
                Transition transition = scarabR.getTransition(data.getParameters().getInteger("transition_id"));
            	transition.setConditionsArray(aConditions, operator);
            	transition.save();
            	TransitionManager.getMethodResult().remove(transition, TransitionManager.GET_CONDITIONS);
                AttributeManager.clear();        
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                Attribute attribute = scarabR.getAttribute(data.getParameters().getInteger("attId"));
            	attribute.setConditionsArray(aConditions, operator);
            	attribute.save();
                AttributeManager.clear();        
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
            	RModuleAttribute rma = RModuleAttributePeer.retrieveByPK(data.getParameters().getInteger("moduleId"), data.getParameters().getInteger("attId"), data.getParameters().getInteger("issueTypeId"));
                rma.setConditionsArray(aConditions, operator);
                RModuleAttributeManager.clear();
                ConditionManager.clear();
                rma.save(); /** TODO: do we need it? **/
                AttributeManager.clear();        
        		break;
        	case ScarabConstants.BLOCKED_MODULE_ISSUE_TYPE_OBJECT:
        	    RModuleIssueType rmit = RModuleIssueTypePeer.retrieveByPK(scarabR.getCurrentModule().getModuleId(), data.getParameters().getInteger("issuetypeid"));
        		rmit.setConditionsArray(aConditions, operator);
        	    rmit.save();
        	    RModuleIssueTypeManager.clear();
        	    ConditionManager.clear();
                AttributeManager.clear();        
        	    break;
        	case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.saveConditions(user, module, aConditions, operator);
        	    break;
        }
    }
16
              
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                throw new TorqueException(e);
            }
              
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
              
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
              
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
              
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
              
// in java/org/tigris/scarab/om/Attachment.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/om/AttributeValuePeer.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
886
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ScarabUser getUser(Object userId) throws TorqueException
    {
        return ScarabUserTool.getUser(userId);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private void ensure_List_has_MIT_data(MITList currentList, Module module, IssueType issueType) throws TorqueException 
    {
        if(currentList != null)
        {
            MITListItem item = currentList.getFirstItem();
            if(item != null)
            {
                if(item.getModule() == null)
                {
                    // Ensure the item has been assigned to a module
                    item.setModule(module);
                }

                IssueType itemIssueType = item.getIssueType();
                if(itemIssueType == null)
                {
                    // item's issueType has not beeen initialized ?
                    if(issueType == null)
                    {                        
                        // Our local IssueType has also not been created ??
                        issueType = new IssueType();
                    }
                    item.setIssueType(issueType);
                    itemIssueType = issueType;
                }
                if (itemIssueType.getIssueTypeId() == null)
                {
                    // No definition means "Do not care". Hence it is equal to "any issueType from any module":
                    itemIssueType.setIssueTypeId(MITListPeer.ALL_MODULES_ISSUETYPES.intValue());
                }
            }
            
        }
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String getRModuleAttributeDisplayName(final Attribute attribute) throws TorqueException
    {
        final ScarabUser user = (ScarabUser)data.getUser();
        MITList mitList = user.getCurrentMITList();
        return getRModuleAttributeDisplayName(attribute, mitList);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String getRModuleAttributeDisplayName(final Attribute attribute, final MITList mitlist)
            throws TorqueException
    {
        return mitlist.getAttributeDisplayName(attribute);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List<RModuleAttribute> getRModuleUserAttributes() throws TorqueException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        Module module   = user.getCurrentModule();
        List<RModuleAttribute> result = getRModuleUserAttributes(user, module);
        return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List<RModuleAttribute> getRModuleUserAttributes(Query q) throws TorqueException
    {
        List<RModuleAttribute> result = getRModuleUserAttributes();
        if(result.size() == 0) 
        {
            /*
             * When we get here, then the current user uses a public query for which
             * he/she has not yet created a customization (ake call s the query for the
             * first time ever). Since we assume, that the original creator of the 
             * query has configured the query wisely, we take a copy of the creators 
             * customization here. Hence the new user gets a reasonable default setting.
             * However the new user can configure the query independently from the originators
             * customization.
             */
            ScarabUser me       = (ScarabUser)data.getUser();  // the userId of the current user
            MITList currentList = q.getMITList();              // The query MIT-list
            ScarabUser owner    = q.getScarabUser();           // The originator of the query
            if(owner==null)
            {
                Log.get().warn("Current Query does not contain a User");
                owner = me;
                if(owner == null)
                {
                    owner = this.getCurrentUser();
                    if(owner == null)
                    {
                        Log.get().warn("Current session has no user assigned. Can not retrieve RModuleUserAttributes.");
                        return result;
                    }
                }
            }
            Module module       = me.getCurrentModule();       // The current module
            IssueType theIssueType = this.getIssueType();      // The current issue Type
            currentList = currentList.copy();                  // Here we make a physical copy
            currentList.setUserId(owner.getUserId());          // We set the current users uid 

            /*
             * Now we recall the Userattributes of the originators customisation,
             * but get it in to our copy. The nice side effect: The copy will be
             * added to the database, thus it gets persistent. Subsequent calls
             * to this method will always return the copy from the database.
            */
            result = getRModuleUserAttributes(owner, module, theIssueType, currentList );
            
        }
        return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private List<RModuleAttribute> getRModuleUserAttributes(ScarabUser user, Module module) throws TorqueException
    {
        Integer defaultIssueTypeId = (Integer)MITListPeer.ALL_MODULES_ISSUETYPES.intValue();
        IssueType theIssueType = this.getIssueType(defaultIssueTypeId);

        if(issueListColumns == null || issueListColumns.size() == 0)
        {
        	issueListColumns= getRModuleUserAttributes(user, module, theIssueType);
			if (issueListColumns == null)
	        {
	            issueListColumns = Collections.EMPTY_LIST;
	        }
        	initialIssueListColumnsSize = issueListColumns.size();
        }

        // DEP: Not sure about this initial list stuff, or if we need it..
        if (initialIssueListColumnsSize > issueListColumns.size())
        {
            TemplateContext context =
                (TemplateContext) data.getTemp(Turbine.CONTEXT);
            context.put("columnLimitExceeded", Boolean.TRUE);
        }
        return issueListColumns;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Query getQuery() throws TorqueException
    {
        String queryId = data.getParameters().getString("queryId");
        if(queryId==null)
        {
            queryId = data.getParameters().getString("query");
        }
                
        if (queryId != null || query == null)
        {
            query = getQuery(queryId);
        }
        return query;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private Query getQuery(String queryId) throws TorqueException
    {
        try
        {
            if (queryId == null || queryId.length() == 0)
            {
                query = Query.getInstance();
                Module m = getCurrentModule();
                if(m != null)
                {
                    query.setModule(m);
                }
            }
            else
            {
                query = QueryManager
                      .getInstance(new NumberKey(queryId), false);
            }
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            throw e;
        }
        return query;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueType getIssueType() throws TorqueException
    {
        return getIssueType((Integer)null);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueType getIssueType(Integer defaultIssueTypeId) throws TorqueException
    {
        if (issueType == null)
        {
            String key = data.getParameters()
                .getString("issuetypeid");
            if (key == null)
            {
                // get new issue type
                issueType = new IssueType(defaultIssueTypeId);
            }
            else
            {
                try
                {
                    issueType = IssueTypeManager
                        .getInstance(new NumberKey(key), false);
                }
                catch (Exception e)
                {
                    issueType = new IssueType(defaultIssueTypeId);
                }
            }
        }
        return issueType;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueType getCurrentIssueType()throws TorqueException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        IssueType curit = user.getCurrentIssueType();
        if (curit == null)
        {
            Integer curitID = data.getParameters().getInteger(ScarabConstants.CURRENT_ISSUE_TYPE);
            if(curitID.intValue()!=0)
            {
                curit = IssueTypeManager.getInstance(curitID);
            }
        }
        return curit;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String getNextIssue()
        throws TorqueException
    {
        String nextIssueId = null;
        int nextIssueIndex = getNextIssuePosInList() - 1;
        List searchResults = getCurrentSearchResults();
        if(nextIssueIndex>=0 && nextIssueIndex< searchResults.size() )
        {
            nextIssueId = ((QueryResult)searchResults.get(nextIssueIndex)).getUniqueId();
        }
        return nextIssueId;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String getPrevIssue()
    throws TorqueException
    {
        String prevIssueId = null;
        int prevIssueIndex = getPrevIssuePosInList() - 1;
        List searchResults = getCurrentSearchResults();
        if(prevIssueIndex>=0 && prevIssueIndex<searchResults.size() )
        {
            prevIssueId = ((QueryResult)searchResults.get(prevIssueIndex)).getUniqueId();
        }
        return prevIssueId;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public static MITListItem convertToMITListItem(RModuleIssueType rmit)
    throws TorqueException
    {
        MITListItem item = MITListItemManager.getInstance();
        item.setModuleId(rmit.getModuleId());
        item.setIssueTypeId(rmit.getIssueTypeId());
        return item;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public void initializeLink(ScarabLink link)
            throws org.apache.torque.TorqueException
        {
            int offset = listOffset + count;
            link.setPage("ViewIssue.vm")
                .addPathInfo("id", ((QueryResult)current).getUniqueId())
                .addPathInfo(POS_IN_LIST, offset);
        }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getSortedAttributeOptions() throws TorqueException
    {
        return AttributeOptionPeer.getSortedAttributeOptions();
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getSortedAttributeOptionsForModule(Module module) throws TorqueException
    {
        return AttributeOptionPeer.getSortedAttributeOptions(module);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean isAnonymousLoginAllowed()
        throws TorqueException
    {
        return ScarabUserTool.isAnonymousLoginAllowed();
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public RModuleOption getFirstModuleOption(Module module, IssueType issueType, String displayValue) throws TorqueException
    {
        RModuleOption result = null;
        if (module != null && issueType != null && displayValue != null)
        {
            result = RModuleOption.getFirstRMO(module.getModuleId(), issueType.getIssueTypeId(), displayValue);
        }
        return result;
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public boolean hasRequestedRole(ScarabUser user, Role role, Group group)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, HAS_REQUESTED_ROLE, user); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(PendingGroupUserRolePeer.USER_ID, user.getUserId());
            result = PendingGroupUserRolePeer.doSelect(crit);
            ScarabCache.put(result, this, HAS_REQUESTED_ROLE);
        }
        else 
        {
            result = (List)obj;
        }
        boolean b = false;
        Iterator iter = result.iterator();
        while (iter.hasNext()) 
        {
            PendingGroupUserRole pmur = (PendingGroupUserRole)iter.next();
            if (pmur.getRoleName().equals(role.getName())
                && ((Module)group).getModuleId().equals(pmur.getGroupId())) 
            {
                b = true;
                break;
            }
        }
        return b;
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getPendingGroupUserRoles(Module module)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_PENDING, module); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(PendingGroupUserRolePeer.GROUP_ID, module.getModuleId());
            result = PendingGroupUserRolePeer.doSelect(crit);
            ScarabCache.put(result, this, GET_PENDING);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static ScarabUser getUser(Object userId)
        throws TorqueException
    {
        if (userId == null)
        {
            return null;
        }

        if(IssueSearch.SEARCHING_USER_KEY.equalsIgnoreCase(userId.toString()))
        {
            return IssueSearch.getSearchingUserPlaceholder();
        }

        Integer pk = null;
        try
        {
            pk = new Integer(userId.toString());
        }
        catch( NumberFormatException e)
        {
            return null;
        }

        ScarabUser su = null;
        try
        {
            su = ScarabUserManager.getInstance(pk);
        }
        catch (TorqueException e)
        {
            return null;
        }
        return su;
    }
              
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static boolean isAnonymousLoginAllowed()
        throws TorqueException
    {
        return ScarabUserManager.anonymousAccessAllowed();
    }
              
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static int getNotificationCount(Module module, ScarabUser user) throws TorqueException
    {
        return NotificationStatusManager.getNotificationCount(module, user);
    }
              
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static boolean wantEdit(ScarabUser user, Issue issue, RunData data) throws TorqueException
    {
        Object testExists = data.getParameters().get("edit_attributes");
        if(testExists != null)
        {
            boolean wantToOpenEditor = data.getParameters().getBoolean("edit_attributes");
            return wantToOpenEditor;
        }

        // Now check for condition
        String behaviour = GlobalParameterManager.getStringFromHierarchy(
                                                  "scarab.edit.behaviour",
                                                  issue.getModule(),
                                                  "default");
        if(behaviour.equals("smart"))
        {
            if(issue.isSealed())
            {
                return false; // don't open this issue in edit mode, because it is sealed!
            }
            // Check if user is assigned to issue.
            // If that is the case, open the issue
            // in edit mode per default.
            List<AttributeValue> userAttributeValues = issue.getUserAttributeValues(user);
            Iterator<AttributeValue> iter = userAttributeValues.iterator();
            while(iter.hasNext())
            {
                AttributeValue attributeValue = iter.next();
                Attribute attribute = attributeValue.getAttribute();
                String permission = attribute.getPermission();
                if("Issue | Edit".equals(permission))
                {
                    return true; // if can edit and want edit, lets edit ...
                }
            }
        }
        else
        {
            // Scarab default behaviour: Open issue in view mode.
        }
        return false;
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public String getRequiredModifyPermission(Issue issue) throws TorqueException
    {        
        String editPermission = ScarabSecurity.ISSUE__EDIT;
        
        String status = getTurbineProperty("scarab.common.status.id");
        if (status != null)
        {
            String value = getTurbineProperty("scarab.common.status.sealed");
            if(value != null)
            {
                AttributeValue attval = issue.getAttributeValue(status);
                if(attval != null && attval.getValue().equals(value))
                {
                    String permissionString = getTurbineProperty("scarab.common.status.sealed.modifyPermission");
                    if(permissionString != null)
                    {
                        editPermission = permissionString;
                    }
                }
            }
        }
        return editPermission;
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getCustomization(Object moduleId, Object userId, Object activityCode) throws TorqueException
    {
        NotificationRulePeer nfp = new NotificationRulePeer();
        List result = nfp.getCustomization(moduleId, userId, activityCode);
        return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public static Notification getEmptyNotificationFor(ScarabUser user, ScarabModule module) throws TorqueException
    {
        return new Notification(user, module);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public static NotificationRule getNotificationRule(Integer ruleId) throws TorqueException
    {
        NotificationRule result = NotificationRuleManager.getInstance(ruleId);
        return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getModulesFromIssueList(List issues)
        throws TorqueException
    {
        return ModuleManager.getInstancesFromIssueList(issues);
    }
              
// in java/org/tigris/scarab/search/CachedQuery.java
private static List executeSelect( String sql )
        throws TorqueException
    {
		List result;
		try 
    	{
	        long queryStartTime = System.currentTimeMillis();

		    result = BasePeer.executeQuery(sql);
	        
	        logLongRunningQuery(sql, System.currentTimeMillis() - queryStartTime);
        }
	    catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
        return result;
    }
              
// in java/org/tigris/scarab/attribute/SelectOneAttribute.java
public void init() throws TorqueException
    {
        /*
        if (getAttributeValue() == null &&
             !getScarabIssue().isNew()) 
        {
            Criteria crit = new Criteria()
                .add(ScarabIssueAttributeValuePeer.ATTRIBUTE_ID, 
                     getScarabAttribute().getPrimaryKey());
            
            Vector results = getScarabIssue()
                .getScarabIssueAttributeValues(crit); 
            if (results.size() == 1) // if value is not found it will be null until
            {
                setScarabIssueAttributeValue(
                    (ScarabIssueAttributeValue)results.get(0));
            }
        }
        if (getScarabIssueAttributeValue() != null)
        {
            value = getOptionById(
                getScarabIssueAttributeValue().getOptionId());
            loaded = true;
        }
        */
    }
              
// in java/org/tigris/scarab/attribute/OptionAttribute.java
public void setOption(final RModuleOption option)
        throws TorqueException
    {
        setOptionIdOnly(option.getOptionId());
        setValueOnly(option.getDisplayValue());
    }
              
// in java/org/tigris/scarab/attribute/OptionAttribute.java
public Object loadResources() throws TorqueException
    {
        return null;
    }
              
// in java/org/tigris/scarab/attribute/FreeFormAttribute.java
public void init() throws TorqueException
    {
        
        if (getIssue().isNew()) 
        {
            setDeleted(false);                
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setChainedValue(final AttributeValue  v)
        throws TorqueException, ScarabException
    {
        if (v == null)
        {
            this.chainedValue = null;
        }
        else 
        {        
            if (v.getAttributeId() == null && getAttributeId() != null) 
            {
                v.setAttributeId(getAttributeId());
            }
            else if (v.getAttribute() != null 
                     && !v.getAttribute().equals(getAttribute()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainAttributeValues,
                                          v.getAttributeId(),
                                          getAttributeId());
            }
            
            if (v.getIssueId() == null && getIssueId() != null) 
            {
                v.setIssueId(getIssueId());
            }
            else if (v.getIssue() != null 
                      && !v.getIssue().equals(getIssue()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainIssues,
                                          v.getIssueId(),
                                          getIssueId());
            }

            if (this.chainedValue == null) 
            {
                this.chainedValue = v;
            }
            else 
            {
                chainedValue.setChainedValue(v);
            }
            
            if (activitySet != null) 
            {
                v.startActivitySet(activitySet);
            }        
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setAttributeId(Integer nk)
        throws TorqueException
    {
        super.setAttributeId(nk);
        if (chainedValue != null) 
        {
            chainedValue.setAttributeId(nk);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setIssueId(Long nk)
        throws TorqueException
    {
        super.setIssueId(nk);
        if (chainedValue != null) 
        {
            chainedValue.setIssueId(nk);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void startActivitySet(ActivitySet activitySet)
        throws ScarabException, TorqueException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionCanNotStartActivitySet);
        }
        
        if (this.activitySet == null) 
        {
            this.activitySet = activitySet;
        }
        else
        {
            throw new ScarabException(L10NKeySet.ExceptionActivitySetInProgress);
        }
/*
This is wrong. It prevented the old/new value stuff from working properly!
If we have an existing issue and we change some attributes, then when the
history was created, the data was not valid in it for some reason. I'm not
quite sure why this was added. (JSS)

Leaving here so that John can remove or fix.

        oldOptionIdIsSet = false;
        oldValueIsSet = false;
        oldOptionId = null;
        oldValue = null;
*/

        // Check for previous active activities on this attribute 
        // If they exist, set old value for this activity
        List result = null;
        final Issue issue = getIssue();
        if (issue != null)
        {
            result = issue
                .getActivitiesWithNullEndDate(getAttribute());
        }
        if (result != null && result.size() > 0)
        {
            for (int i=0; i<result.size(); i++)
            {
                final Activity a = (Activity)result.get(i);
                oldOptionId = a.getNewOptionId();
                oldValue = a.getNewValue();
            }
        }
        if (chainedValue != null) 
        {
            chainedValue.startActivitySet(activitySet);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setOptionId(Integer optionId)
        throws TorqueException
    {
        if ( optionId != null ) 
        {
            Module module = getIssue().getModule();
            IssueType issueType = getIssue().getIssueType();
            if (module == null || issueType == null)
            {
                AttributeOption option = AttributeOptionManager
                    .getInstance(optionId);
                setValueOnly(option.getName());
            }
            else 
            {
                // FIXME! create a key and get the instance directly from
                // the manager.
                List options = null;

                options = module
                        .getRModuleOptions(getAttribute(), issueType);
                if(options != null)
                {
                    for (int i = options.size() - 1; i >= 0; i--)
                    {
                        RModuleOption option = (RModuleOption) options.get(i);
                        if (option.getOptionId().equals(optionId))
                        {
                            setValueOnly(option.getDisplayValue());
                            break;
                        }
                    }
                }
            }            
        }
        else
        {
            // any reason to set a option_id to null, once its already set?
            setValueOnly(null);
        }
        
        setOptionIdOnly(optionId);
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
protected void setOptionIdOnly(Integer optionId)
        throws TorqueException
    {
        if (!ObjectUtils.equals(optionId, getOptionId()))
        { 
            // if the value is set multiple times before saving only
            // save the last saved value
            if (!isNew() && !oldOptionIdIsSet && getOptionId() != null) 
            {
                oldOptionId = getOptionId();
                oldOptionIdIsSet = true;
            }
            super.setOptionId(optionId);
        }  
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setUserId(Integer userId)
        throws TorqueException
    {
        if (userId != null) 
        {
            ScarabUser user = ScarabUserManager.getInstance(userId);
            setValueOnly(user.getUserName());
        }
        else
        {
            // any reason to set a user_id to null, once its already set?
            setValueOnly(null);
        }

        setUserIdOnly(userId);
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
protected void setUserIdOnly(Integer value)
        throws TorqueException
    {
        if (!ObjectUtils.equals(value, getUserId()))
        { 
            // if the value is set multiple times before saving only
            // save the last saved value
            if (!isNew() && !oldUserIdIsSet) 
            {
                oldUserId = getUserId();
                oldUserIdIsSet = true;
            }
            super.setUserId(value);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setOptionIds(final Integer[] ids)
        throws TorqueException, ScarabException
    {
        if (ids != null && ids.length > 0) 
        {
            setOptionId(ids[0]);
        }
        if (ids != null && ids.length > 1) 
        {
            for (int i=1; i<ids.length; i++) 
            {            
                final AttributeValue av = AttributeValue                
                    .getNewInstance(getAttributeId(), getIssue());
                setChainedValue(av);
                av.setOptionId(ids[i]);
            }
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setUserIds(final Integer[] ids)
        throws TorqueException, ScarabException
    {
        if (ids != null && ids.length > 0) 
        {
            setUserId(ids[0]);
        }
        if (ids != null && ids.length > 1) 
        {
            for (int i=1; i<ids.length; i++) 
            {            
                final AttributeValue av = AttributeValue                
                    .getNewInstance(getAttributeId(), getIssue());
                setChainedValue(av);
                av.setUserId(ids[i]);
            }
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public boolean isRequired()
       throws TorqueException, ScarabException
    {
        return getRModuleAttribute().getRequired();
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public RModuleAttribute getRModuleAttribute()
        throws TorqueException, ScarabException
    {
        final Issue issue = getIssue();
        RModuleAttribute rma = null;
        if (issue != null)
        {
            final Module module = issue.getModule();
            if (module != null)
            {
                rma = module.getRModuleAttribute(
                    getAttribute(), getIssue().getIssueType());
            }
            else
            {
                throw new ScarabException (L10NKeySet.ExceptionGeneral,
                        "Module is null: Please report this issue."); //EXCEPTION
            }
        }
        else
        {
            throw new ScarabException (L10NKeySet.ExceptionGeneral,
                    "Issue is null: Please report this issue."); //EXCEPTION
        }
        return rma;
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public String getDisplayValue(ScarabLocalizationTool l10n)
    throws TorqueException
    {
        String displayValue = null;

        if(getAttribute().isOptionAttribute())
        {
            try
            {
                displayValue = getIssue().getModule().getRModuleOption( getAttributeOption(), getIssue().getIssueType()).getDisplayValue();
                //displayValue = getRModuleAttribute().getDisplayValue();
            }
            catch (NullPointerException npe)
            {
                // Something wrong in the database ?
                displayValue="";
            }
        }
        else if(getAttribute().isUserAttribute())
        {
            displayValue = getScarabUser().getUserName();
        }
		else if(getAttribute().isDateAttribute())
		{
			displayValue = DateAttribute.dateFormat(getValue(), L10NKeySet.ShortDateDisplay.getMessage(l10n));
		}
        else
        {
            displayValue = getValue();
        }
        return displayValue;
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public AttributeOption getAttributeOption()
        throws TorqueException
    {
        return getAttribute()
            .getAttributeOption(getOptionId());
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public boolean isQuickSearchAttribute()
        throws TorqueException
    {
        boolean result = false;
        List qsAttributes = getIssue().getIssueType()
            .getQuickSearchAttributes(getIssue().getModule());
        for (int i=qsAttributes.size()-1; i>=0; i--) 
        {
            if (((Attribute)qsAttributes.get(i)).equals(getAttribute())) 
            {
                result = true;
                break;
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public static AttributeValue getNewInstance(
        RModuleAttribute rma, Issue issue) throws TorqueException
    {
        return getNewInstance(rma.getAttributeId(), issue);
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public static AttributeValue getNewInstance(
        Integer attId, Issue issue) throws TorqueException
    {
        Attribute attribute = AttributeManager.getInstance(attId);
        return getNewInstance(attribute, issue);
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public static synchronized AttributeValue getNewInstance(
        Attribute attribute, Issue issue) throws TorqueException
    {
        AttributeValue attv = null;
        try
        {
            String className = attribute
                .getAttributeType().getJavaClassName();
            attv = (AttributeValue)
                Class.forName(className).newInstance();
            attv.setAttribute(attribute);
            attv.setIssue(issue);
    
            attv.init();
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        return attv;
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public AttributeValue copy() throws TorqueException
    {
        AttributeValue copyObj = AttributeValue
            .getNewInstance(getAttributeId(), getIssue());
        return copyInto(copyObj);
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public AttributeValue copy(Connection con) throws TorqueException 
    {
        throw new RuntimeException("Unimplemented method AttributeValue:copy(Connection conn)");
        //return copy();
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void save(Connection dbcon)
        throws TorqueException
    {
        if (isModified() && !getAttribute().isUserAttribute())
        {
            try
            {
                checkActivitySet(L10NKeySet.ExceptionCanNotSaveAttributeValue);
            }
            catch (Exception e)
            {
                throw new TorqueException(e);
            }
            if (saveActivity == null)
            {            
                if (getDeleted())
                {
                    saveActivity = ActivityManager
                        .create(getIssue(), getAttribute(), activitySet, 
                                ActivityType.ATTRIBUTE_CHANGED, null, null, getNumericValue(), ScarabConstants.INTEGER_0,
                                getUserId(), null, getOptionId(), null, 
                                getValue(), null, dbcon);
                }
                else
                {
                    saveActivity = ActivityManager
                        .create(getIssue(), getAttribute(), activitySet, 
                                ActivityType.ATTRIBUTE_CHANGED, null, null, oldNumericValue, getNumericValue(),
                                oldUserId, getUserId(), oldOptionId, getOptionId(), 
                                oldValue, getValue(), dbcon);
                }
            }
        }
        super.save(dbcon);
        if (chainedValue != null) 
        {
            chainedValue.save(dbcon);
        }
        endActivitySet();
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public void setProperties(final AttributeValue attVal1)
        throws TorqueException
    {
        setAttribute(attVal1.getAttribute());
        setIssue(attVal1.getIssue());
        setNumericValue(attVal1.getNumericValue());
        setOptionId(attVal1.getOptionId());
        setUserId(attVal1.getUserId());
        setValue(attVal1.getValue());
    }
              
// in java/org/tigris/scarab/om/RIssueTypeAttribute.java
public void setIsDefaultText(boolean b)
        throws TorqueException
    {
        if (b && !getDefaultTextFlag()) 
        {
            // get related RIAs
            List rias = getIssueType().getRIssueTypeAttributes(false);
            
            // make sure no other rma is selected
            for (int i=0; i<rias.size(); i++) 
            {
                RIssueTypeAttribute ria = (RIssueTypeAttribute)rias.get(i);
                if (ria.getDefaultTextFlag()) 
                {
                    ria.setDefaultTextFlag(false);
                    ria.save();
                    break;
                }
            }
        }
        setDefaultTextFlag(b);
    }
              
// in java/org/tigris/scarab/om/RIssueTypeAttribute.java
public boolean getIsDefaultText()
        throws TorqueException
    {
        boolean isDefault = getDefaultTextFlag();
        if (!isDefault && getAttribute().isTextAttribute()) 
        {
            // get related RIAs
            List rias = getIssueType().getRIssueTypeAttributes();
            
            // check if another is chosen
            boolean anotherIsDefault = false;
            for (int i=0; i<rias.size(); i++) 
            {
                RIssueTypeAttribute ria = (RIssueTypeAttribute)rias.get(i);
                if (ria.getDefaultTextFlag()) 
                {
                    anotherIsDefault = true;
                    break;
                }
            }
            
            if (!anotherIsDefault) 
            {
                // locate the default text attribute
                for (int i=0; i<rias.size(); i++) 
                {
                    RIssueTypeAttribute ria = (RIssueTypeAttribute)rias.get(i);
                    if (ria.getAttribute().isTextAttribute()) 
                    {
                        if (ria.getAttributeId().equals(getAttributeId())) 
                        {
                            isDefault = true;
                        }
                        else 
                        {
                            anotherIsDefault = true;
                        }
                        
                        break;
                    }
                }
            }            
        }
        return isDefault;
    }
              
// in java/org/tigris/scarab/om/RIssueTypeAttribute.java
public void delete()
         throws TorqueException
    {
        if (Log.get().isDebugEnabled()) 
        {
            Log.get().debug(
                "Deleting SCARAB_R_ISSUETYPE_ATTRIBUTE where issuetype id=" 
                + getIssueTypeId() + " and attribute id=" + getAttributeId());
        }        
        Criteria c = new Criteria()
            .add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
            .add(RIssueTypeAttributePeer.ATTRIBUTE_ID, getAttributeId());
        RIssueTypeAttributePeer.doDelete(c);
        Attribute attr = getAttribute();
        String attributeType = null;
        attributeType = (attr.isUserAttribute() ? IssueType.USER : IssueType.NON_USER);
        getIssueType().getRIssueTypeAttributes(false, attributeType).remove(this);

        // delete issuetype-option mappings
        if (attr.isOptionAttribute())
        {
            List optionList = getIssueType().getRIssueTypeOptions(attr, false);
            if (optionList != null && !optionList.isEmpty()) 
            {            
                ArrayList optionIdList = new ArrayList(optionList.size());
                for (int i =0; i<optionList.size(); i++)
                { 
                    optionIdList.add(((RIssueTypeOption)optionList.get(i)).getOptionId());
                }
                Criteria c2 = new Criteria()
                    .add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId())
                    .addIn(RIssueTypeOptionPeer.OPTION_ID, optionIdList);
                RIssueTypeOptionPeer.doDelete(c2);
            }
        }
    }
              
// in java/org/tigris/scarab/om/RIssueTypeAttribute.java
public RIssueTypeAttribute copyRia()
         throws TorqueException
    {                
        RIssueTypeAttribute ria = new RIssueTypeAttribute(); 
        ria.setIssueTypeId(getIssueTypeId());
        ria.setAttributeId(getAttributeId());
        ria.setActive(getActive());
        ria.setRequired(getRequired());
        ria.setOrder(getOrder());
        ria.setQuickSearch(getQuickSearch());
        ria.setDefaultTextFlag(getDefaultTextFlag());
        return ria;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public MITList copy() throws TorqueException
    {
        MITList copyObj = new MITList();
        copyObj.setName(getName());
        copyObj.setActive(getActive());
        copyObj.setModifiable(getModifiable());
        copyObj.setUserId(getUserId());

        List v = getMITListItems();
        for (int i = 0; i < v.size(); i++)
        {
            MITListItem obj = (MITListItem) v.get(i);
            copyObj.addMITListItem(obj.copy());
        }

        return copyObj;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public MITList getPermittedSublist(String permission, ScarabUser user)
        throws TorqueException
    {
        String[] perms = { permission };
        return getPermittedSublist(perms, user);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public MITList getPermittedSublist(String[] permissions, ScarabUser user)
        throws TorqueException
    {
        MITList sublist = new MITList();
        ScarabUser userB = getScarabUser();
        if (userB != null)
        {
            sublist.setScarabUser(userB);
        }
        List items = getExpandedMITListItems();
        sublist.isAllMITs = this.isAllMITs;
        Module[] validModules = user.getModules(permissions);

        Set moduleIds = new HashSet();
        for (int j = 0; j < validModules.length; j++)
        {
            moduleIds.add(validModules[j].getModuleId());
        }

        for (Iterator i = items.iterator(); i.hasNext();)
        {
            MITListItem item = (MITListItem) i.next();
            if (moduleIds.contains(item.getModuleId()))
            {
                // use a copy of the item here to avoid changing the the
                // list_id of the original
                sublist.addMITListItem(item.copy());
            }
        }

        return sublist;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public Module getModule() throws TorqueException
    {
        if (!isSingleModule())
        {
            throw new IllegalStateException(
                "method should not be called on"
                    + " a list including more than one module."); //EXCEPTION
        }
        return getModule(getFirstItem());
    }
              
// in java/org/tigris/scarab/om/MITList.java
public IssueType getIssueType() throws TorqueException
    {
        if (!isSingleIssueType())
        {
            throw new IllegalStateException(
                "method should not be called on"
                    + " a list including more than one issue type."); //EXCEPTION
        }
        return getFirstItem().getIssueType();
    }
              
// in java/org/tigris/scarab/om/MITList.java
Module getModule(MITListItem item) throws TorqueException
    {
        Module module = null;
        if (item.getModuleId() == null)
        {
            ScarabUser user = getScarabUser();
            module = user.getCurrentModule();
        }
        else
        {
            module = item.getModule();
        }
        return module;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public void setScarabUser(ScarabUser v) throws TorqueException
    {
        if (v == null)
        {
            throw new IllegalArgumentException("cannot set user to null."); //EXCEPTION
        }

        super.setScarabUser(v);
        aScarabUser = v;
        expandedList = null;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public ScarabUser getScarabUser() throws TorqueException
    {
        ScarabUser user = null;
        if (aScarabUser == null)
        {
            user = super.getScarabUser();
        }
        else
        {
            user = aScarabUser;
        }
        return user;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getAttributes(final boolean activeOnly, final boolean commonOnly)
            throws TorqueException,
            DataSetException
    {

        Set matchingAttributes = new HashSet();
        Iterator iter = iterator();
        while (iter.hasNext())
        {
            final MITListItem item = (MITListItem)iter.next();
            final List rmas = getModule(item).getRModuleAttributes(
                    item.getIssueType());
            for (Iterator i = rmas.iterator(); i.hasNext();)
            {
                final RModuleAttribute rma = (RModuleAttribute) i.next();
                final Attribute att = rma.getAttribute();
                if ((!activeOnly || rma.getActive()))
                {
                    boolean wantedAttribute = (commonOnly) ? isCommon(att,
                            activeOnly) : true;
                    if (size() == 1 || wantedAttribute)
                    {
                        matchingAttributes.add(att);
                    }
                }
            }
            if(commonOnly)
            {
                // don't need to iterate through other Items, because the
                // intersection with the first MITListItem is sufficient
                // to fulfill the commonOnly rule.
                break;
            }
        }

        // Finally copy the resultset into an ArrayList for
        // compatibility to older implementaiton of this method.
        final List result = new ArrayList();
        iter = matchingAttributes.iterator();
        while(iter.hasNext())
        {
            result.add(iter.next());
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonAttributes() throws TorqueException, DataSetException
    {
        return getAttributes(true,true);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonAttributes(final boolean activeOnly) throws TorqueException, DataSetException
    {
        return getAttributes(activeOnly, true);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final Attribute attribute, final boolean activeOnly)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        addToCriteria(
            crit,
            RModuleAttributePeer.MODULE_ID,
            RModuleAttributePeer.ISSUE_TYPE_ID);
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID, attribute.getAttributeId());
        if (activeOnly)
        {
            crit.add(RModuleAttributePeer.ACTIVE, true);
        }

        return size() == RModuleAttributePeer.count(crit);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final Attribute attribute) throws TorqueException, DataSetException
    {
        return isCommon(attribute, true);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonNonUserAttributes() throws TorqueException, DataSetException
    {
        assertNotEmpty();

        final List matchingAttributes = new ArrayList();
        final MITListItem item = getFirstItem();

        final List rmas = getModule(item).getRModuleAttributes(item.getIssueType());
        final Iterator i = rmas.iterator();
        while (i.hasNext())
        {
            final RModuleAttribute rma = (RModuleAttribute) i.next();
            final Attribute att = rma.getAttribute();
            if (!att.isUserAttribute() && rma.getActive() && isCommon(att))
            {
                matchingAttributes.add(att);
            }
        }

        return matchingAttributes;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonOptionAttributes() throws TorqueException, DataSetException
    {
        assertNotEmpty();

        final List matchingAttributes = new ArrayList();
        final MITListItem item = getFirstItem();

        final List rmas = getModule(item).getRModuleAttributes(item.getIssueType());
        final Iterator i = rmas.iterator();
        while (i.hasNext())
        {
            final RModuleAttribute rma = (RModuleAttribute) i.next();
            final Attribute att = rma.getAttribute();
            if (att.isOptionAttribute() && rma.getActive() && isCommon(att))
            {
                matchingAttributes.add(att);
            }
        }

        return matchingAttributes;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List<Attribute> getCommonUserAttributes(final boolean activeOnly) 
        throws TorqueException, DataSetException
    {
        List<Attribute> attributes = null;
        if (isSingleModuleIssueType())
        {
            attributes =
                getModule().getUserAttributes(getIssueType(), activeOnly);
        }
        else
        {
            final List<Attribute> matchingAttributes = new ArrayList<Attribute>();
            final MITListItem item = getFirstItem();
            final List<RModuleAttribute> rmas =
                getModule(item).getRModuleAttributes(
                    item.getIssueType(),
                    activeOnly,
                    Module.USER);
            final Iterator<RModuleAttribute> i = rmas.iterator();
            while (i.hasNext())
            {
                final RModuleAttribute rma = i.next();
                final Attribute att = rma.getAttribute();
                if ((!activeOnly || rma.getActive())
                    && isCommon(att, activeOnly))
                {
                    matchingAttributes.add(att);
                }
            }
            attributes = matchingAttributes;
        }
        return attributes;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List<Attribute> getCommonUserAttributes() throws TorqueException, DataSetException
    {
        return getCommonUserAttributes(false);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List<ScarabUser> getPotentialAssignees(boolean includeCommitters)
        throws TorqueException, DataSetException
    {
        List<ScarabUser> users = new ArrayList<ScarabUser>();
        List<String> perms = getUserAttributePermissions();
        if (includeCommitters && !perms.contains(ScarabSecurity.ISSUE__ENTER))
        {
            perms.add(ScarabSecurity.ISSUE__ENTER);
        }
        if (isSingleModule())
        {
            ScarabUser[] userArray = getModule().getUsers(perms);
            for (int i = 0; i < userArray.length; i++)
            {
                users.add(userArray[i]);
            }
        }
        else
        {
            MITListItem item = getFirstItem();
            ScarabUser[] userArray = getModule(item).getUsers(perms);
            List<Module> modules = getModules();
            for (int i = 0; i < userArray.length; i++)
            {
                boolean validUser = false;
                ScarabUser user = userArray[i];
                for (Iterator<String> j = perms.iterator(); j.hasNext() && !validUser;)
                {
                    validUser = user.hasPermission(j.next(), modules);
                }
                if (validUser)
                {
                    users.add(user);
                }
            }
        }
        return users;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List<String> getUserAttributePermissions() throws TorqueException, DataSetException
    {
        final List userAttrs = getCommonUserAttributes();
        final List<String> permissions = new ArrayList<String>();
        for (int i = 0; i < userAttrs.size(); i++)
        {
            final String permission = ((Attribute) userAttrs.get(i)).getPermission();
            if (!permissions.contains(permission))
            {
                permissions.add(permission);
            }
        }
        return permissions;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getAllRModuleUserAttributes() 
    throws TorqueException, DataSetException, TurbineSecurityException
    {
        List rmuas = getSavedRMUAs();
        return rmuas;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleUserAttributes() 
        throws TorqueException, DataSetException, TurbineSecurityException
    {
        final List matchingRMUAs = new ArrayList();
        List rmuas = getSavedRMUAs();
        Iterator i = rmuas.iterator();
        final ScarabUser user = getScarabUser();
        while (i.hasNext())
        {
            final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
            final Attribute att = rmua.getAttribute();
            if (isCommon(att, false))
            {
                matchingRMUAs.add(rmua);
            }
        }

        // None of the saved RMUAs are common for these pairs
        // Delete them and seek new ones.
        if (matchingRMUAs.isEmpty())
        {
            i = rmuas.iterator();
            while (i.hasNext())
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                rmua.delete(user);
            }
            final int sizeGoal = 3;
            int moreAttributes = sizeGoal;

            // First try saved RMUAs for first module-issuetype pair
            final MITListItem item = getFirstItem();
            final Module module = getModule(item);
            final IssueType issueType = item.getIssueType();
            rmuas = user.getRModuleUserAttributes(module, issueType);
            // Next try default RMUAs for first module-issuetype pair
            if (rmuas.isEmpty())
            {
                rmuas = module.getDefaultRModuleUserAttributes(issueType);
            }

            // Loop through these and if find common ones, save the RMUAs
            i = rmuas.iterator();
            while (i.hasNext() && moreAttributes > 0)
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                final Attribute att = rmua.getAttribute();
                if (isCommon(att, false) && !matchingRMUAs.contains(rmua))
                {
                    final RModuleUserAttribute newRmua =
                        getNewRModuleUserAttribute(att);
                    newRmua.setOrder(1);
                    newRmua.save();
                    matchingRMUAs.add(rmua);
                    moreAttributes--;
                }
            }

            // if nothing better, go with random common attributes
            moreAttributes = sizeGoal - matchingRMUAs.size();
            if (moreAttributes > 0)
            {
                Iterator attributes = getCommonAttributes(false).iterator();
                int k = 1;
                while (attributes.hasNext() && moreAttributes > 0)
                {
                    Attribute att = (Attribute) attributes.next();
                    boolean isInList = false;
                    i = matchingRMUAs.iterator();
                    while (i.hasNext())
                    {
                        RModuleUserAttribute rmua =
                            (RModuleUserAttribute) i.next();
                        if (rmua.getAttribute().equals(att))
                        {
                            isInList = true;
                            break;
                        }
                    }
                    if (!isInList)
                    {
                        RModuleUserAttribute rmua =
                            getNewRModuleUserAttribute(att);
                        rmua.setOrder(k++);
                        rmua.save();
                        matchingRMUAs.add(rmua);
                        moreAttributes--;
                    }
                }
            }
        }

        return matchingRMUAs;
    }
              
// in java/org/tigris/scarab/om/MITList.java
protected RModuleUserAttribute getNewRModuleUserAttribute(Attribute attribute)
        throws TorqueException
    {
        RModuleUserAttribute result = RModuleUserAttributeManager.getInstance();
        result.setUserId(getUserId());
        result.setAttributeId(attribute.getAttributeId());

        if (isSingleModuleIssueType())
        {
            result.setModuleId(getModule().getModuleId());
            result.setIssueTypeId(getIssueType().getIssueTypeId());
        }

        if (!isNew())
        {
            result.setListId(getListId());
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/MITList.java
private List getMatchingRMOs(List rmos) throws TorqueException, Exception
    {
        List matchingRMOs = new ArrayList();
        if (rmos != null)
        {
            for (Iterator i = rmos.iterator(); i.hasNext();)
            {
                RModuleOption rmo = (RModuleOption) i.next();
                AttributeOption option = rmo.getAttributeOption();
                if (rmo.getActive() && isCommon(option))
                {
                    matchingRMOs.add(rmo);
                }
            }
        }
        return matchingRMOs;
    }
              
// in java/org/tigris/scarab/om/MITList.java
protected List getSavedRMUAs() throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RModuleUserAttributePeer.USER_ID, getUserId());
        if (!isNew())
        {
            Long listId = getListId();
            crit.add(RModuleUserAttributePeer.LIST_ID, listId);
        }
        else
        {
            Integer moduleId    = null;
            Integer issueTypeId = null;
            
            if(isSingleModuleIssueType())
            {
                Module module = getModule();
                moduleId     = module.getModuleId();
               
                IssueType issueType = getIssueType();
                issueTypeId   = issueType.getIssueTypeId();
            }
            else if (isSingleModule())
            {
                moduleId    = getModule().getModuleId();
            }
            else if (isSingleIssueType())
            {
                IssueType issueType = getIssueType();
                issueTypeId   = issueType.getIssueTypeId();
            }
            
            crit.add(RModuleUserAttributePeer.LIST_ID,       null);
            crit.add(RModuleUserAttributePeer.MODULE_ID,     moduleId);
            crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, issueTypeId);
        }

        crit.addAscendingOrderByColumn(
            RModuleUserAttributePeer.PREFERRED_ORDER);

        return RModuleUserAttributePeer.doSelect(crit);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonLeafRModuleOptions(final Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getLeafRModuleOptions(
                attribute,
                item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleOptionTree(Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getOptionTree(attribute, item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }  
        catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getAllRModuleOptionTree(Attribute attribute)
        throws TorqueException
    {
        assertNotEmpty();
    
        // Get all isse types from this MITList
        List listItems = getExpandedMITListItems();

        // Get all attribute options from all issue types for the requested attribute
        List attributeOptions = new ArrayList();
        if (listItems!=null) {
            Iterator listItemIterator = listItems.iterator();
            while (listItemIterator.hasNext()) {
                MITListItem item = (MITListItem)listItemIterator.next();
                List rmos = getModule(item).getOptionTree(attribute, item.getIssueType());
                mergeRModuleOptionsIgnoreDuplicates(attributeOptions, rmos);
            }
        }
    
        return attributeOptions;
    }
              
// in java/org/tigris/scarab/om/MITList.java
private void mergeRModuleOptionsIgnoreDuplicates(List masterList, List addList)
        throws TorqueException {
        // Get a set of all existing option ids
        Set optionIds = new HashSet();
        Iterator masterIterator = masterList.iterator();
        while (masterIterator.hasNext()) {
            RModuleOption option = (RModuleOption)masterIterator.next();
            optionIds.add(option.getOptionId());
        }
  
        // add all options not already present in the list, add only active options
        Iterator addIterator = addList.iterator();
        while (addIterator.hasNext()) {
            RModuleOption rmo = (RModuleOption)addIterator.next();
            if (rmo.getActive() && !optionIds.contains(rmo.getOptionId())) {
                masterList.add(rmo);
            }
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getDescendantsUnion(AttributeOption option) throws TorqueException
    {
        assertNotEmpty();

        List matchingRMOs = new ArrayList();
        Iterator items = iterator();
        while (items.hasNext())
        {
            MITListItem item = (MITListItem) items.next();
            IssueType issueType = item.getIssueType();
            RModuleOption parent =
                getModule(item).getRModuleOption(option, issueType);
            if (parent != null)
            {
                Iterator i = parent.getDescendants(issueType).iterator();
                while (i.hasNext())
                {
                    RModuleOption rmo = (RModuleOption) i.next();
                    if (!matchingRMOs.contains(rmo))
                    {
                        matchingRMOs.add(rmo);
                    }
                }
            }
        }

        return matchingRMOs;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final AttributeOption option) throws TorqueException, DataSetException
    {
        return isCommon(option, true);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final AttributeOption option, final boolean activeOnly)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        addToCriteria(
            crit,
            RModuleOptionPeer.MODULE_ID,
            RModuleOptionPeer.ISSUE_TYPE_ID);
        crit.add(RModuleOptionPeer.OPTION_ID, option.getOptionId());
        if (activeOnly)
        {
            crit.add(RModuleOptionPeer.ACTIVE, true);
        }

        return size() == RModuleOptionPeer.count(crit);
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List<Module> getModules() throws TorqueException
    {
        assertNotEmpty();

        List items = getExpandedMITListItems();
        ArrayList modules = new ArrayList(items.size());
        Iterator<MITListItem> i = items.iterator();
        while (i.hasNext())
        {
            Module m = i.next().getModule();
            if (!modules.contains(m))
            {
                modules.add(m);
            }
        }
        return modules;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public void addToCriteria(Criteria crit) throws TorqueException
    {
        addToCriteria(crit, IssuePeer.MODULE_ID, IssuePeer.TYPE_ID);
    }
              
// in java/org/tigris/scarab/om/MITList.java
private void addToCriteria(
        Criteria crit,
        String moduleField,
        String issueTypeField)
        throws TorqueException
    {
        if (!isSingleModule() && isSingleIssueType())
        {
            crit.addIn(moduleField, getModuleIds());
            crit.add(issueTypeField, getIssueType().getIssueTypeId());
        }
        else if (isSingleModule() && !isSingleIssueType())
        {
            crit.add(moduleField, getModule().getModuleId());
            crit.addIn(issueTypeField, getIssueTypeIds());
        }
        else if (isAllMITs)
        {
            crit.addIn(moduleField, getModuleIds());
            // we do this to avoid including templates in results
            crit.addIn(issueTypeField, getIssueTypeIds());
        }
        else if (size() > 0)
        {
            List items = getExpandedMITListItems();
            Iterator i = items.iterator();
            Criteria.Criterion c = null;
            while (i.hasNext())
            {
                MITListItem item = (MITListItem) i.next();
                Criteria.Criterion c1 =
                    crit.getNewCriterion(
                        moduleField,
                        item.getModuleId(),
                        Criteria.EQUAL);
                Criteria.Criterion c2 =
                    crit.getNewCriterion(
                        issueTypeField,
                        item.getIssueTypeId(),
                        Criteria.EQUAL);
                c1.and(c2);
                if (c == null)
                {
                    c = c1;
                }
                else
                {
                    c.or(c1);
                }
            }
            crit.add(c);
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public void addAll(MITList list) throws TorqueException
    {
        List currentList = getExpandedMITListItems();
        for (Iterator i = list.getExpandedMITListItems().iterator();
            i.hasNext();
            )
        {
            MITListItem item = (MITListItem) i.next();
            if (!currentList.contains(item))
            {
                addMITListItem(item);
            }
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public void addMITListItem(MITListItem item) throws TorqueException
    {
        super.addMITListItem(item);
        expandedList = null;
        calculateIsAllMITs(item);
    }
              
// in java/org/tigris/scarab/om/MITList.java
private void addIssueTypes(Module module, List items) throws TorqueException
    {
        Iterator rmits = module.getRModuleIssueTypes().iterator();
        while (rmits.hasNext())
        {
            MITListItem newItem = MITListItemManager.getInstance();
            newItem.setModuleId(module.getModuleId());
            newItem.setIssueTypeId(
                ((RModuleIssueType) rmits.next()).getIssueTypeId());
            newItem.setListId(getListId());
            items.add(newItem);
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public void save(Connection con) throws TorqueException
    {
        super.save(con);
        if (itemsScheduledForDeletion != null
            && !itemsScheduledForDeletion.isEmpty())
        {
            List itemIds = new ArrayList(itemsScheduledForDeletion.size());
            for (Iterator iter = itemsScheduledForDeletion.iterator();
                iter.hasNext();
                )
            {
                MITListItem item = (MITListItem) iter.next();
                if (!item.isNew())
                {
                    itemIds.add(item.getItemId());
                }
            }
            if (!itemIds.isEmpty())
            {
                Criteria crit = new Criteria();
                crit.addIn(MITListItemPeer.ITEM_ID, itemIds);
                MITListItemPeer.doDelete(crit);
            }
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public String getAttributeDisplayName(final Attribute attribute) 
        throws TorqueException
    {
        String displayName = null;
        for( MITListItem item : ((List<MITListItem>)getExpandedMITListItems()))
        {
            final String nameCandidate = item.getAttributeDisplayName(attribute);

            displayName = displayName == null ? nameCandidate : displayName;
            
            if(!displayName.equals(nameCandidate))
            {
                displayName = attribute.getName();
                break;
            }            
        }
        return displayName;
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        GlobalParameter gp = (GlobalParameter)om;
        Serializable moduleId = gp.getModuleId();
        String name = gp.getName();
        if (moduleId == null)
        {
            // if altering a global parameter, its possible the
            // module overrides are invalid.
            getMethodResult().removeAll(MANAGER_KEY, name);
        }
        else
        {
            getMethodResult().remove(MANAGER_KEY, name, GET_STRING,
                                     moduleId);
        }
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
private static GlobalParameter getInstance(String name)
        throws TorqueException
    {
        return getInstance(name, null);
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
private static GlobalParameter getInstance(String name, Module module)
        throws TorqueException
    {
        GlobalParameter result = null;
        Criteria crit = new Criteria();
        crit.add(GlobalParameterPeer.NAME, name);
        if (module == null)
        {
            crit.add(GlobalParameterPeer.MODULE_ID, null);
        }
        else
        {
            crit.add(GlobalParameterPeer.MODULE_ID, module.getModuleId());
        }
        List parameters = GlobalParameterPeer.doSelect(crit);
        if (!parameters.isEmpty())
        {
            result = (GlobalParameter)parameters.get(0);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
private static String getStringModule(String name, Module module )
        throws TorqueException
    {
        String value = (String) getMethodResult()
                .get(MANAGER_KEY, name, GET_STRING, module.getModuleId());

        if(value == null)
        {
            GlobalParameter p = getInstance(name, module);

            if (p != null)
            {
                value = p.getValue();
            }
            if(value==null)
            {
                value = "";
            }
            getMethodResult().put(value, MANAGER_KEY, name, GET_STRING, module.getModuleId());
        }
        return value;
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
private static String getStringGlobal(String name)
        throws TorqueException
    {
        String value = (String) getMethodResult()
                .get(MANAGER_KEY, name, GET_STRING );

        if(value == null)
        {
            GlobalParameter p = getInstance(name);

            if (p != null)
            {
                value = p.getValue();
            }
            if(value==null || value.equals(""))
            {
                value = Turbine.getConfiguration().getString(name);
            }
            if(value==null)
            {
                value = "";
            }
            getMethodResult().put(value, MANAGER_KEY, name, GET_STRING);
        }
        return value;
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static String getString(String name)
        throws TorqueException
    {
        return getStringGlobal(name);
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static String getString(String name, Module module)
        throws TorqueException
    {
        String value = getStringModule(name, module);
        if (value.equals(""))
        {
            value = getStringGlobal(name);
        }
        return value;
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static String getStringFromHierarchy(String name, Module module, String def)
        throws TorqueException
    {
      String value = getStringModule( name, module );

      if(value.equals(""))
      {
          Module parentModule = module.getParent();
         if(parentModule != null)
         {
             value = getStringFromHierarchy(name, parentModule, def);
         }
      }

        if(value.equals(""))
        {
            value = getStringGlobal(name);
        }

        if(value.equals(""))
        {
            value = def;
        }

        return value;
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static void setString(String name, String value)
        throws TorqueException
    {
      setString(name, null, value);
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static void setString(String name, Module module, String value)
        throws TorqueException
    {
        GlobalParameter p = getInstance(name, module);
        if (p == null)
        {
            p = getInstance();
            p.setName(name);
            p.setModuleId(module.getModuleId());
        }
        p.setValue(value);
        p.save();
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static boolean getBoolean(String name)
        throws TorqueException
    {
        return toBoolean(getString(name));
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static boolean getBoolean(String name, Module module)
        throws TorqueException
    {
        return toBoolean(getString(name, module));
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static boolean getBooleanFromHierarchy(String name, Module module, boolean def)
        throws TorqueException
    {
        String defAsString = (def)? "TRUE":"FALSE";
        return toBoolean(getStringFromHierarchy(name, module, defAsString ));
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static void setBoolean(String name, boolean value)
        throws TorqueException
    {
        setString(name, (value ? "TRUE" : "FALSE"));
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static void setBoolean(String name, Module module, boolean value)
        throws TorqueException
    {
        setString(name, module, (value ? "TRUE" : "FALSE"));
    }
              
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static List getStringList(String name)
        throws TorqueException
    {
        return toStringList(getString(name));
    }
              
// in java/org/tigris/scarab/om/Query.java
public ScarabUser getScarabUser() 
        throws TorqueException
    {
        ScarabUser user = this.scarabUser;
        if (user == null) 
        {
            user = super.getScarabUser();
        }
        
        return user;
    }
              
// in java/org/tigris/scarab/om/Query.java
public void setScarabUser(ScarabUser  v) 
        throws TorqueException
    {
        this.scarabUser = v;
        super.setScarabUser(v);
    }
              
// in java/org/tigris/scarab/om/Query.java
public void setModule(Module me)
        throws TorqueException
    {
        if (me == null) 
        {
            setModuleId((Integer)null);            
        }
        else 
        {
            Integer id = me.getModuleId();
            if (id == null) 
            {
                throw new TorqueException("Modules must be saved prior to " +
                    "being associated with other objects."); //EXCEPTION
            }
            setModuleId(id);
        }        
    }
              
// in java/org/tigris/scarab/om/Query.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
              
// in java/org/tigris/scarab/om/Query.java
public boolean canDelete(ScarabUser user)
        throws TorqueException
    {
        // can delete a query if they have delete permission
        // Or if is their personal query
        return (user.hasPermission(ScarabSecurity.ITEM__DELETE, getModule())
                || (user.getUserId().equals(getUserId()) 
                   && (getScopeId().equals(Scope.PERSONAL__PK))));
    }
              
// in java/org/tigris/scarab/om/Query.java
public boolean canEdit(ScarabUser user)
        throws TorqueException
    {
        return canDelete(user);
    }
              
// in java/org/tigris/scarab/om/Query.java
public boolean saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped query, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        Exception exception=null; // temporary store a thrown exception

        if (getScopeId().equals(Scope.PERSONAL__PK) 
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        }
        else
        {
            setApproved(false);

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");

                final ScarabUser[] toUsers = module
                    .getUsers(ScarabSecurity.ITEM__APPROVE);

                if (Log.get().isDebugEnabled()) 
                {
                    if (toUsers == null || toUsers.length ==0) 
                    {
                        Log.get().debug("No users to approve query.");    
                    }
                    else 
                    {
                        Log.get().debug("Users to approve query: ");    
                        for (int i=0; i<toUsers.length; i++) 
                        {
                            Log.get().debug(toUsers[i].getEmail());
                        }  
                    }          
                }
                
                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewQueryRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx,
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null,
                        template);
                }
                catch (Exception e)
                {
                    exception = e;
                }
            }
        }
        if (getMITList() != null) 
        {
            getMITList().save();
            // it would be good if this updated our list id, but it doesn't
            // happen automatically so reset it.
            setMITList(getMITList());            
        }
        save();
        if(exception != null)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral, exception);
        }
        return true;
    }
              
// in java/org/tigris/scarab/om/Query.java
public MITList getMITList()
        throws TorqueException
    {
        MITList mitlist = super.getMITList();
        if (mitlist == null) 
        {
            mitlist = MITListManager.getSingleItemList(getModule(),
                getIssueType(), null);
        }
        return mitlist;
    }
              
// in java/org/tigris/scarab/om/Query.java
public void subscribe(ScarabUser user, Integer frequencyId)
        throws TorqueException
    {
        RQueryUser rqu = getRQueryUser(user);
        rqu.setSubscriptionFrequency(frequencyId);
        rqu.setIsSubscribed(true);
        rqu.save();
    }
              
// in java/org/tigris/scarab/om/Query.java
public void unSubscribe(ScarabUser user)
        throws TorqueException
    {
        RQueryUser rqu = getRQueryUser(user);
        if (rqu.getIsdefault())
        {
            rqu.setIsSubscribed(false);
            rqu.save();
        }
        else
        {
            rqu.delete(user);
        }
    }
              
// in java/org/tigris/scarab/om/Query.java
public RQueryUser getRQueryUser(ScarabUser user)
        throws TorqueException
    {
        RQueryUser result = null;
        Object obj = ScarabCache.get(this, GET_R_QUERY_USER, user); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(RQueryUserPeer.QUERY_ID, getQueryId());
            crit.add(RQueryUserPeer.USER_ID, user.getUserId());
            List rqus = RQueryUserPeer.doSelect(crit);
            if (!rqus.isEmpty())
            {
                result = (RQueryUser)rqus.get(0);
            }
            else
            {
                result = new RQueryUser();
                result.setQuery(this);
                result.setUserId(user.getUserId());
            }
            ScarabCache.put(result, this, GET_R_QUERY_USER, user);
        }
        else 
        {
            result = (RQueryUser)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Query.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/Query.java
public void delete(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module)
          || (user.getUserId().equals(getUserId()) 
             && getScopeId().equals(Scope.PERSONAL__PK)))
        {
            // Delete user-query maps.
            final List rqus = getRQueryUsers();
            for (int i=0; i<rqus.size(); i++)
            {
                final RQueryUser rqu = (RQueryUser)rqus.get(i);
                rqu.delete(user);
            }
            setDeleted(true);
            save();
            
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/Query.java
public void copyQuery(ScarabUser user)
         throws TorqueException
    {                
         Query newQuery = new Query();
         newQuery.setName(getName() + " (copy)");
         newQuery.setDescription(getDescription());
         newQuery.setValue(getValue());
         newQuery.setModuleId(getModuleId());
         newQuery.setIssueTypeId(getIssueTypeId());
         newQuery.setListId(getListId());
         newQuery.setApproved(getApproved());
         newQuery.setCreatedDate(new Date());
         newQuery.setUserId(user.getUserId());
         newQuery.setScopeId(getScopeId());
         newQuery.save();

         RQueryUser rqu = getRQueryUser(user);
         if (rqu != null)
         {
             RQueryUser rquNew = new RQueryUser();
             rquNew.setQueryId(newQuery.getQueryId());
             rquNew.setUserId(user.getUserId());
             rquNew.setSubscriptionFrequency(rqu.getSubscriptionFrequency());
             rquNew.setIsdefault(rqu.getIsdefault());
             rquNew.setIsSubscribed(rqu.getIsSubscribed());
             rquNew.save();
         }
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(ActivityPeer.ISSUE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity getInstance(String id)
        throws TorqueException
    {
        return getInstance(new Long(id));
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createNumericActivity(Issue issue, Attribute attribute,
                                                 ActivitySet activitySet, 
                                                 Attachment attachment,
                                                 Integer oldNumericValue,
                                                 Integer newNumericValue)
        throws TorqueException
    {
        return create(issue,attribute,activitySet,ActivityType.ATTRIBUTE_CHANGED,null,attachment,
                      oldNumericValue, newNumericValue,
                      null, null, null, null, null, null);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createUserActivity(Issue issue, Attribute attribute,
                                                 ActivitySet activitySet, 
                                                 Attachment attachment,
                                                 Integer oldUserId,
                                                 Integer newUserId)
        throws TorqueException
    {
        String oldUsername = null;
        String newUsername = null;
        if (oldUserId != null)
        {
            oldUsername = ScarabUserManager.getInstance(oldUserId).getUserName();
        }
        if (newUserId != null)
        {
            newUsername = ScarabUserManager.getInstance(newUserId).getUserName();
        }
        return create(issue,attribute,activitySet,ActivityType.USER_ATTRIBUTE_CHANGED,null,attachment,
                      null, null,
                      oldUserId, newUserId, 
                      null, null, oldUsername, newUsername);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createAddDependencyActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 Depend depend)
        throws TorqueException
    {
        return create(issue,null,activitySet,ActivityType.DEPENDENCY_CREATED,null,null,depend,
                      null, null,
                      null, null,
                      null, null,
                      null, depend.getDependType().getName(), null);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createChangeDependencyActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 Depend depend,
                                                 String oldTextValue,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,null,activitySet,ActivityType.DEPENDENCY_CHANGED,null,null,depend,
                      null, null,
                      null, null,
                      null, null,
                      oldTextValue, newTextValue, null);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createDeleteDependencyActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 Depend depend)
        throws TorqueException
    {
        return create(issue,null,activitySet,ActivityType.DEPENDENCY_DELETED,null,null,depend,
                      null, null,
                      null, null,
                      null, null,
                      depend.getDependType().getName(), null, null);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,null,activitySet,type,null,null,
                      null, null,
                      null, null,
                      null, null,
                      null, newTextValue);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 Attachment attachment)
        throws TorqueException
    {
        return create(issue,null,activitySet,type,null,attachment,
                      null, null,
                      null, null,
                      null, null,
                      null, null);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue, Attribute attribute,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 String oldTextValue,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,attribute,activitySet,type,null,null,
                      null, null,
                      null, null,
                      null, null,
                      oldTextValue, newTextValue);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 Attachment attachment, 
                                                 String oldTextValue,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,null,activitySet,type,null,attachment,
                      null, null,
                      null, null,
                      null, null,
                      oldTextValue, newTextValue);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue, Attribute attribute,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 String description,
                                                 Attachment attachment,
                                                 String oldTextValue,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,attribute,activitySet,type,description,attachment,
                      null, null,
                      null, null,
                      null, null,
                      oldTextValue, newTextValue);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createReportIssueActivity(Issue issue, 
                                                     ActivitySet activitySet,
                                                     String message)
        throws TorqueException
    {
        return create(issue, AttributeManager.getInstance(ScarabConstants.INTEGER_0), 
                      activitySet, ActivityType.ISSUE_CREATED, null, null,
                      null, null, null, null, null, null, null, null);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createDeleteIssueActivity(Issue issue, ActivitySet activitySet)
        throws TorqueException
    {
        return create(issue, AttributeManager.getInstance(ScarabConstants.INTEGER_0), 
                activitySet, ActivityType.ISSUE_DELETED, null, null,
                null, null, null, null, null, null, null, null);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity create(Issue issue, Attribute attribute, 
                       ActivitySet activitySet, ActivityType type, 
                       String description, Attachment attachment, 
                       Integer oldNumericValue, Integer newNumericValue,
                       Integer oldUserId, Integer newUserId,
                       Integer oldOptionId, Integer newOptionId,
                       String oldTextValue, String newTextValue)
         throws TorqueException
    {
        return create(issue,attribute,activitySet,type,description,attachment,null,
                      oldNumericValue, newNumericValue,
                      oldUserId, newUserId,
                      oldOptionId, newOptionId,
                      oldTextValue, newTextValue, null);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity create(Issue issue, Attribute attribute, 
                       ActivitySet activitySet, ActivityType type, 
                       String description, Attachment attachment, 
                       Integer oldNumericValue, Integer newNumericValue,
                       Integer oldUserId, Integer newUserId,
                       Integer oldOptionId, Integer newOptionId,
                       String oldTextValue, String newTextValue,
                       Connection dbCon)
         throws TorqueException
    {
        return create(issue,attribute,activitySet,type,description,attachment,null,
                      oldNumericValue, newNumericValue,
                      oldUserId, newUserId,
                      oldOptionId, newOptionId,
                      oldTextValue, newTextValue, dbCon);
    }
              
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity create(Issue issue, Attribute attribute,
                       ActivitySet activitySet, ActivityType type, 
                       String description, Attachment attachment, Depend depend,
                       Integer oldNumericValue, Integer newNumericValue,
                       Integer oldUserId, Integer newUserId,
                       Integer oldOptionId, Integer newOptionId,
                       String oldTextValue, String newTextValue, 
                       Connection dbCon)
         throws TorqueException
    {
        Activity activity = ActivityManager.getInstance();
        activity.setIssue(issue);
        if (attribute == null)
        {
            attribute = Attribute.getInstance(0);
        }
        activity.setAttribute(attribute);
        activity.setActivitySet(activitySet);
        activity.setOldNumericValue(oldNumericValue);
        activity.setNewNumericValue(newNumericValue);
        activity.setOldUserId(oldUserId);
        activity.setNewUserId(newUserId);
        activity.setOldOptionId(oldOptionId);
        activity.setNewOptionId(newOptionId);
        activity.setOldValue(oldTextValue);
        activity.setNewValue(newTextValue);
        activity.setDepend(depend);
        activity.setDescription(description);
        activity.setActivityType(type!=null?type.getCode():null);
        if (attachment != null)
        {
            activity.setAttachment(attachment);
        }
        if (dbCon == null) 
        {
            try
            {
                activity.save();
            }
            catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        else 
        {
            activity.save(dbCon);
        }
        // Make sure new activity is added to activity cache
        try
        {
            issue.addActivity(activity);
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        return activity;
    }
              
// in java/org/tigris/scarab/om/PendingGroupUserRole.java
public void delete()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(PendingGroupUserRolePeer.GROUP_ID, getGroupId());
        crit.add(PendingGroupUserRolePeer.USER_ID, getUserId());
        crit.add(PendingGroupUserRolePeer.ROLE_NAME, getRoleName());
        PendingGroupUserRolePeer.doDelete(crit);
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(String key)
        throws TorqueException
    {
        return getInstance(new NumberKey(key));
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(Integer key)
        throws TorqueException
    {
        return getInstance(new NumberKey(key));
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final ActivitySetType tt, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return getInstance(tt.getTypeId(), user, null);
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final ActivitySetType tt, 
            final ScarabUser user, 
            final Attachment attachment)
        throws TorqueException, ScarabException
    {
        return getInstance(tt.getTypeId(), user, attachment);
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
            final ScarabUser user)
        throws TorqueException,ScarabException
    {
        return getInstance(typeId, user, null);
    }
              
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
                                          final ScarabUser user, 
                                          final Attachment attachment)
        throws TorqueException,ScarabException
    {
        if (attachment != null && attachment.getAttachmentId() == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNeedToSaveAttachement);
        }
        final ActivitySet activitySet = new ActivitySet();
        activitySet.setTypeId(typeId);
        activitySet.setCreatedBy(user.getUserId());
        activitySet.setCreatedDate(new Date());
        if (attachment != null && 
            attachment.getData() != null &&
            attachment.getData().length() > 0)
        {
            activitySet.setAttachment(attachment);
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Activity.java
public AttributeOption getOldAttributeOption() throws TorqueException
    {
        if (oldAttributeOption==null && (getOldValue() != null))
        {
            oldAttributeOption = AttributeOptionManager
                .getInstance(new Integer(getOldValue()));
        }
        return oldAttributeOption;
    }
              
// in java/org/tigris/scarab/om/Activity.java
public AttributeOption getNewAttributeOption() throws TorqueException
    {
        if (newAttributeOption==null && (getNewValue() != null))
        {
            newAttributeOption = AttributeOptionManager
                .getInstance(new Integer(getNewValue()));
        }
        return newAttributeOption;
    }
              
// in java/org/tigris/scarab/om/Activity.java
public void save(Connection dbCon)
        throws TorqueException
    {
        if (isNew()) 
        {
            Criteria crit = new Criteria();
            // If there are previous activities on this attribute and value
            // Set End Date
            if (this.getOldValue() != null)
            {
                crit.add(ActivityPeer.ISSUE_ID, getIssueId());
                crit.add(ActivityPeer.ATTRIBUTE_ID, getAttributeId());
                crit.add(ActivityPeer.END_DATE, null);
                crit.add(ActivityPeer.NEW_VALUE, this.getOldValue());
                List<Activity> result = ActivityPeer.doSelect(crit);
                int resultSize = result.size();
                if (resultSize > 0)
                {
                    for (int i=0; i<resultSize;i++)
                    {
                        Activity a = (Activity)result.get(i);
                        a.setEndDate(getActivitySet().getCreatedDate());
                        a.save(dbCon);
                    }
                }
            }
        }
        // If they have just deleted a user assignment, set end date
        if (getAttribute().isUserAttribute() && this.getNewUserId() == null && this.getOldUserId() != null)
        {
            this.setEndDate(getActivitySet().getCreatedDate());
        }
        
        super.save(dbCon);
    }
              
// in java/org/tigris/scarab/om/Activity.java
public Activity copy(Issue issue, ActivitySet activitySet)
        throws TorqueException
    {
        Activity newA = new Activity();
        newA.setIssueId(issue.getIssueId());
        newA.setDescription(getDescription());
        newA.setAttributeId(getAttributeId());
        newA.setTransactionId(activitySet.getActivitySetId());
        newA.setOldNumericValue(getOldNumericValue());
        newA.setNewNumericValue(getNewNumericValue());
        newA.setOldUserId(getOldUserId());
        newA.setNewUserId(getNewUserId());
        newA.setOldValue(getOldValue());
        newA.setNewValue(getNewValue());
        newA.setDependId(getDependId());
        newA.setEndDate(getEndDate());
        newA.setAttachmentId(getAttachmentId());
        newA.setActivityType(getActivityType());
        newA.save();
        return newA;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void save(Connection con) throws TorqueException
    {
        if (isModified())
        {
            if (isNew())
            {
                super.save(con);
            }
            else
            { 
                RIssueTypeAttribute ria = null;
                try
                {
                    ria = getIssueType().getRIssueTypeAttribute(getAttribute());
                    if ((ria != null && ria.getLocked()))
                    {
                    throw new TorqueException(getAttribute().getName() + " is locked"); //EXCEPTION
                    }
                    else
                    {
                        super.save(con);
                    }
                }
                catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void delete()
         throws TorqueException, ScarabException
    {                
         delete(false);
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
protected void delete(final boolean overrideLock)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        final IssueType issueType = IssueTypeManager
           .getInstance(getIssueTypeId(), false);
        if (issueType.getLocked() && !overrideLock)
        { 
            throw new ScarabException(L10NKeySet.CannotDeleteAttributeFromLockedIssueType);
        }            
        else
        {
            final Criteria c = new Criteria()
                .add(RModuleAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleAttributePeer.doDelete(c);
            final Attribute attr = getAttribute();
            String attributeType = null;
            attributeType = (attr.isUserAttribute() ? Module.USER : Module.NON_USER);
            module.getRModuleAttributes(getIssueType(), false, attributeType)
                                        .remove(this);
            WorkflowFactory.getInstance().deleteWorkflowsForAttribute(
                                          attr, module, getIssueType());

            // delete module-user-attribute mappings
            final Criteria crit = new Criteria()
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attr.getAttributeId())
                .add(RModuleUserAttributePeer.MODULE_ID, 
                     getModuleId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                     getIssueTypeId());
            RModuleUserAttributePeer.doDelete(crit);

            // delete module-option mappings
            if (attr.isOptionAttribute())
            {
                final List optionList = module.getRModuleOptions(attr, 
                                  IssueTypePeer.retrieveByPK(getIssueTypeId()), 
                                  false);
                if (optionList != null && !optionList.isEmpty())
                {
                    final List optionIdList =
                        new ArrayList(optionList.size());
                    for (int i = 0; i < optionList.size(); i++)
                    { 
                        optionIdList.add(((RModuleOption)
                                          optionList.get(i))
                                         .getOptionId());
                    }
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID, getModuleId())
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,
                             getIssueTypeId())
                        .addIn(RModuleOptionPeer.OPTION_ID, optionIdList);
                    RModuleOptionPeer.doDelete(c2);
                }
            }
        }

        RModuleAttributeManager.removeInstanceFromCache(this);
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
private static List getRMAs(Integer moduleId, Integer issueTypeId)
    throws TorqueException
{
    List result = null;
    Object obj = ScarabCache.get(R_MODULE_ATTTRIBUTE, GET_RMAS, 
                                 moduleId, issueTypeId); 
    if (obj == null) 
    {        
        Criteria crit = new Criteria()
            .add(RModuleAttributePeer.MODULE_ID, moduleId)
            .add(RModuleAttributePeer.ISSUE_TYPE_ID, issueTypeId);
        crit.addAscendingOrderByColumn(
            RModuleAttributePeer.PREFERRED_ORDER);
        result = RModuleAttributePeer.doSelect(crit);
        ScarabCache.put(result, R_MODULE_ATTTRIBUTE, GET_RMAS, 
                        moduleId, issueTypeId);
    }
    else 
    {
        result = (List)obj;
    }
    return result;
}
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
private static List<RModuleAttribute> getRMAs(Integer moduleId)
    throws TorqueException
{
    List<RModuleAttribute> result = null;
    Object obj = ScarabCache.get(R_MODULE_ATTTRIBUTE, GET_RMAS, moduleId); 
    if (obj == null) 
    {        
        Criteria crit = new Criteria()
            .add(RModuleAttributePeer.MODULE_ID, moduleId);
        crit.addAscendingOrderByColumn(
            RModuleAttributePeer.PREFERRED_ORDER);
        result = (List<RModuleAttribute>)RModuleAttributePeer.doSelect(crit);
        ScarabCache.put(result, R_MODULE_ATTTRIBUTE, GET_RMAS, 
                        moduleId);
    }
    else 
    {
        result = (List<RModuleAttribute>)obj;
    }
    return result;
}
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public static List<Integer> getRMAIds(Integer moduleId)
    throws TorqueException
    {
        List<RModuleAttribute> rmas = getRMAs(moduleId);
        Iterator<RModuleAttribute> iter = rmas.iterator();
        List<Integer> result = new ArrayList();
        while(iter.hasNext())
        {
            RModuleAttribute rma = iter.next();
            result.add(rma.getAttributeId());
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public boolean getIsDefaultText()
        throws TorqueException
    {
        boolean isDefault = getDefaultTextFlag();
        if (!isDefault && getAttribute().isTextAttribute()) 
        {
            // get related RMAs
            List rmas = getRMAs(getModuleId(), getIssueTypeId());
            
            // check if another is chosen
            boolean anotherIsDefault = false;
            for (int i=0; i<rmas.size(); i++) 
            {
                RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
                if (rma.getDefaultTextFlag()) 
                {
                    anotherIsDefault = true;
                    break;
                }
            }
            
            if (!anotherIsDefault) 
            {
                // locate the default text attribute
                for (int i=0; i<rmas.size(); i++) 
                {
                    RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
                    if (rma.getAttribute().isTextAttribute()) 
                    {
                        if (rma.getAttributeId().equals(getAttributeId())) 
                        {
                            isDefault = true;
                        }
                        else 
                        {
                            anotherIsDefault = true;
                        }
                        
                        break;
                    }
                }
            }            
        }
        return isDefault;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setIsDefaultText(boolean b)
        throws TorqueException
    {
        if (b && !getDefaultTextFlag()) 
        {
            // get related RMAs
            List rmas = getRMAs(getModuleId(), getIssueTypeId());
            
            // make sure no other rma is selected
            for (int i=0; i<rmas.size(); i++) 
            {
                RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
                if (rma.getDefaultTextFlag()) 
                {
                    rma.setDefaultTextFlag(false);
                    rma.save();
                    break;
                }
            }
        }
        setDefaultTextFlag(b);
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public List<Condition> getConditions() throws TorqueException
    {
        if (collConditions == null)
        {
            Criteria crit = new Criteria();
            crit.add(ConditionPeer.ATTRIBUTE_ID, this.getAttributeId());
            crit.add(ConditionPeer.MODULE_ID, this.getModuleId());
            crit.add(ConditionPeer.ISSUE_TYPE_ID, this.getIssueTypeId());
            crit.add(ConditionPeer.TRANSITION_ID, null);
            collConditions = getConditions(crit);
        }
        return collConditions;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setConditionsArray(Integer aOptionId[], Integer operator) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.ATTRIBUTE_ID, this.getAttributeId());
        crit.add(ConditionPeer.MODULE_ID, this.getModuleId());
        crit.add(ConditionPeer.ISSUE_TYPE_ID, this.getIssueTypeId());
        crit.add(ConditionPeer.TRANSITION_ID, null);
        ConditionPeer.doDelete(crit);
        this.getConditions().clear();
        ConditionManager.clear();
        if (aOptionId != null)
        {
	        for (int i=0; i<aOptionId.length; i++)
	        {
	            if (aOptionId[i].intValue() != 0)
	            {
		            Condition cond = new Condition();
		            cond.setAttribute(this.getAttribute());
		            cond.setOptionId(aOptionId[i]);
		            cond.setTransitionId(null);
		            cond.setIssueTypeId(this.getIssueTypeId());
		            cond.setModuleId(this.getModuleId());
		            cond.setOperator(operator);
		            this.addCondition(cond);
		            cond.save();
	            }
	        }
        }
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public boolean isRequiredIf(Integer optionID) throws TorqueException
    {
        Condition condition = new Condition();
        condition.setAttribute(this.getAttribute());
        condition.setModuleId(this.getModuleId());
        condition.setIssueTypeId(this.getIssueTypeId());
        condition.setTransitionId(new Integer(0));
        condition.setOptionId(optionID);
        return this.getConditions().contains(condition);
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public RModuleAttribute getRModuleAttribute(IssueType issueType)
        throws TorqueException
    {
        Module module = ModuleManager.getInstance(getModuleId());
        Attribute attribute = getAttributeOption().getAttribute();
        return module.getRModuleAttribute(attribute, issueType);
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public List getDescendants(IssueType issueType)
        throws TorqueException
    {
        List descendants = new ArrayList();
        List attrDescendants = getAttributeOption().getDescendants();
        for (int i =0;i < attrDescendants.size(); i++)
        { 
            RModuleOption rmo = null;
            AttributeOption option = (AttributeOption)attrDescendants.get(i);
            rmo = getModule().getRModuleOption(option, issueType);
            if (rmo != null && rmo.getOptionId().equals(option.getOptionId()))
            {
                descendants.add(rmo);
            }
        }
        return descendants;
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public List<RModuleOption> getChildren(IssueType issueType) throws TorqueException {
    	List<RModuleOption> children = new ArrayList<RModuleOption>();
    	
        @SuppressWarnings("unchecked")
    	List<AttributeOption> l = (List<AttributeOption>) this.getAttributeOption().getChildren();
    	
    	for (AttributeOption attrOption : l) {
    		RModuleOption rmo = getModule().getRModuleOption(attrOption, issueType);
            if (rmo != null && rmo.getOptionId().equals(attrOption.getOptionId())) {
            	children.add(rmo);
            }
    	}
    	
    	return children;    	
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public void delete()
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

            final IssueType issueType = IssueTypeManager
               .getInstance(getIssueTypeId(), false);
            if (issueType.getLocked())
            { 
                throw new ScarabException(L10NKeySet.ExceptionDeleteOptionFromLockedIssueType);
            }            
            else
            {
                Integer moduleId    = getModuleId();
                Integer issueTypeId = getIssueTypeId();
                Integer optionId    = getOptionId();
                int orderNumber     = getOrder();

                // delete the option
                final Criteria c = new Criteria()
                    .add(RModuleOptionPeer.MODULE_ID, moduleId)
                    .add(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId)
                    .add(RModuleOptionPeer.OPTION_ID, optionId);
                RModuleOptionPeer.doDelete(c);
                
                // delete associated workflow
                WorkflowFactory.getInstance().deleteWorkflowsForOption(getAttributeOption(), 
                                             module, issueType);

                // ======================================================
                // Correct the ordering of the remaining options
                // ======================================================

                // first retrieve the list of still available option ids
                final List optIds = new ArrayList();
                final List rmos = module.getRModuleOptions(getAttributeOption().getAttribute(), issueType, false);
                for (int i=0; i<rmos.size();i++)
                {
                    final RModuleOption rmo = (RModuleOption)rmos.get(i);
                    optIds.add(rmo.getOptionId());
                }
               
                // Need to perform the correction only if the deleted option had follow up options
                if(optIds.size() > 0)
                {
                    // update the list
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID,       moduleId)
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,   issueTypeId)
                        .addIn(RModuleOptionPeer.OPTION_ID,     optIds)
                        .add(RModuleOptionPeer.PREFERRED_ORDER, orderNumber, Criteria.GREATER_THAN);
                    final List adjustRmos = RModuleOptionPeer.doSelect(c2);
                    for (int j=0; j<adjustRmos.size();j++)
                    {
                        final RModuleOption rmo = (RModuleOption)adjustRmos.get(j);
                        //rmos.remove(rmo);
                        rmo.setOrder(rmo.getOrder() -1);
                        rmo.save();
                        //rmos.add(rmo);
                    }
                }
            }
            // notify module cache of this change
            ((ModuleManager)Torque.getManager(ModuleManager.MANAGED_CLASS))
                .refreshedObject(this);
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public void save(Connection con) throws TorqueException
    {
        if (isModified())
        {
            if (isNew())
            {
                super.save(con);
            }
            else
            {
                Attribute attr = getAttributeOption().getAttribute();
                RIssueTypeAttribute ria = null;
                try
                {
                    ria = getIssueType().getRIssueTypeAttribute(attr);
                    if (ria != null && ria.getLocked())
                    {
                        throw new TorqueException(attr.getName() + "is locked"); //EXCEPTION
                    }
                    else
                    {
                        super.save(con);
                    }
                }
                catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public static List<Integer> getRMOIds(Integer moduleId) throws TorqueException 
    {
        List<RModuleOption> rmos = getRMOs(moduleId);
        Iterator<RModuleOption> iter = rmos.iterator();
        List<Integer> result = new ArrayList();
        while(iter.hasNext())
        {
            RModuleOption rmo = iter.next();
            result.add(rmo.getOptionId());
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public static List<RModuleOption> getRMOs(Integer moduleId)
    throws TorqueException
    {
        List<RModuleOption> result = null;
        Object obj = ScarabCache.get(R_MODULE_OPTION, GET_RMOS, moduleId); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(RModuleOptionPeer.MODULE_ID, moduleId);
            crit.addAscendingOrderByColumn(
                RModuleOptionPeer.PREFERRED_ORDER);
            result = (List<RModuleOption>)RModuleOptionPeer.doSelect(crit);
            ScarabCache.put(result, R_MODULE_OPTION, GET_RMOS, 
                            moduleId);
        }
        else 
        {
            result = (List<RModuleOption>)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public static List<RModuleOption> getRMOs(Integer moduleId, Integer issueTypeId) throws TorqueException
    {
        List<RModuleOption> result = null;
        Object obj = ScarabCache.get(R_MODULE_OPTION, GET_RMOS_FOR_ISSUETYPE , moduleId, issueTypeId); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
            .add(RModuleOptionPeer.MODULE_ID, moduleId)
            .and(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId);
            crit.addAscendingOrderByColumn(
                RModuleOptionPeer.PREFERRED_ORDER);
            result = (List<RModuleOption>)RModuleOptionPeer.doSelect(crit);
            ScarabCache.put(result, R_MODULE_OPTION, GET_RMOS_FOR_ISSUETYPE , moduleId, issueTypeId);
        }
        else 
        {
            result = (List<RModuleOption>)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public static List<RModuleOption> getRMOs(Integer moduleId, Integer issueTypeId, String displayValue) throws TorqueException
    {
        List<RModuleOption> result = null;
        Object obj = ScarabCache.get(R_MODULE_OPTION, GET_RMOS_FOR_ISSUETYPE_AND_VALUE , moduleId, issueTypeId, displayValue); 
        if (obj == null) 
        {
            Criteria crit = new Criteria()
            .add(RModuleOptionPeer.MODULE_ID, moduleId)
            .and(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId)
            .and(RModuleOptionPeer.DISPLAY_VALUE, displayValue);
            crit.addAscendingOrderByColumn(
                RModuleOptionPeer.PREFERRED_ORDER);
            result = (List<RModuleOption>)RModuleOptionPeer.doSelect(crit);
            ScarabCache.put(result, R_MODULE_OPTION, GET_RMOS_FOR_ISSUETYPE_AND_VALUE , moduleId, issueTypeId, displayValue);
        }
        else 
        {
            result = (List<RModuleOption>)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public static RModuleOption getFirstRMO(Integer moduleId, Integer issueTypeId, String displayValue) throws TorqueException
    {
        RModuleOption result = null;
        List<RModuleOption> rmos = getRMOs(moduleId, issueTypeId, displayValue);
        if (rmos != null && rmos.size() > 0)
        {
            result = rmos.get(0);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributeClassManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(AttributeClassPeer.ATTRIBUTE_CLASS_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/AttachmentPeer.java
public static Attachment retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        Attachment result = null;
        Object obj = ScarabCache.get(ATTACHMENT_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseAttachmentPeer.retrieveByPK(pk);
            ScarabCache.put(result, ATTACHMENT_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (Attachment)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/ActivityPeer.java
public static String getNewIssueUniqueId(Issue issue)
        throws TorqueException
    {
        String id = issue.getUniqueId();
        Criteria crit = new Criteria();
        crit.add(ActivityPeer.OLD_VALUE, id);
        crit.add(ActivityPeer.ACTIVITY_TYPE, ActivityType.ISSUE_MOVED.getCode());
        crit.addDescendingOrderByColumn(ActivityPeer.ACTIVITY_ID);
        List list = doSelect(crit);
        if (list != null && list.size() > 0)
            id = ((Activity)list.get(0)).getNewValue();
        return id;
    }
              
// in java/org/tigris/scarab/om/QueryManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        //List listeners = (List)listenersMap
        //    .get(AttributeTypePeer.ATTRIBUTE_TYPE_ID);
        //notifyListeners(listeners, oldOm, om);
        getMethodResult().removeAll(QueryPeer.QUERY_PEER, 
                                    QueryPeer.GET_QUERIES);
        getMethodResult().removeAll(QueryPeer.QUERY_PEER, 
                                    QueryPeer.GET_USER_QUERIES);
        getMethodResult().removeAll(QueryPeer.QUERY_PEER, 
                                    QueryPeer.GET_MODULE_QUERIES);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getInstance()
        throws TorqueException
    {
        return new ScarabUserImpl();
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getInstance(final String username)
        throws TorqueException
    {
        ScarabUser user = (ScarabUser) getMethodResult().get(SCARAB_USER_MANAGER, GET_INSTANCE, username );
        if (user == null)
        {
             user = getManager().getInstanceImpl(username);
             if(user!=null)
                 getMethodResult().put(user, SCARAB_USER_MANAGER, GET_INSTANCE, username);
        }
        return user;
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getInstanceByEmail(final String email) 
        throws TorqueException,ScarabException
    {
        return getManager().getInstanceByEmailImpl(email);
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static List getUsers(final String[] usernames) 
        throws TorqueException
    {
        return getManager().getUsersImpl(usernames);
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected ScarabUser getInstanceImpl(final String username) 
        throws TorqueException
    {
        ScarabUser user = null;
        if (username != null) 
        {
            final Criteria crit = new Criteria();
            crit.add(ScarabUserImplPeer.USERNAME, username);
            crit.setSingleRecord(true);
            final List users = ScarabUserImplPeer.doSelect(crit);
            if (users.size() == 1) 
            {
                user = (ScarabUser)users.get(0);
            }
        }
        return user;
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected ScarabUser getInstanceByEmailImpl(final String email) 
        throws TorqueException,ScarabException
    {
        ScarabUser user = null;
        if (email != null) 
        {
            final Criteria crit = new Criteria();
            crit.add(ScarabUserImplPeer.EMAIL, email);
            final List users = ScarabUserImplPeer.doSelect(crit);
            if (users.size() == 1) 
            {
                user = (ScarabUser)users.get(0);
            }
            else if (users.size() > 1) 
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateUsername); 
            }
        }
        return user;
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected List getUsersImpl(final String[] usernames) 
        throws TorqueException
    {
        List users = null;
        if (usernames != null && usernames.length > 0) 
        {
            final Criteria crit = new Criteria();
            crit.addIn(ScarabUserImplPeer.USERNAME, usernames);
            users = ScarabUserImplPeer.doSelect(crit);            
        }
        return users;
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getAnonymousUser()
	    throws TorqueException
	{
		ScarabUser user = null;
	    if(anonymousAccessAllowed())
	    {
	        String username = getAnonymousUserName();
	        user = getInstance(username);
	    }
	    if (user == null)
	    {
	        try
	        {
	    	    user = (ScarabUser) TurbineSecurity.getAnonymousUser();
	        }
	        catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
	    }
	    return user;
	}
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static String getAnonymousUserName()
	    throws TorqueException
	{
	    String username = GlobalParameterManager.getString("scarab.anonymous.username");
	    return username;
	}
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static boolean anonymousAccessAllowed()
		throws TorqueException
	{
	    boolean allowed = GlobalParameterManager.getBoolean("scarab.anonymous.enable");
	    return allowed;
	}
              
// in java/org/tigris/scarab/om/RModuleAttributePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
              
// in java/org/tigris/scarab/om/RModuleAttributePeer.java
public static RModuleAttribute retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        RModuleAttribute result = null;
        Object obj = ScarabCache.get(RMODULEATTRIBUTE_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseRModuleAttributePeer.retrieveByPK(pk);
            ScarabCache.put(result, RMODULEATTRIBUTE_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (RModuleAttribute)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/RModuleAttributePeer.java
public static void doDelete(RModuleAttribute rma) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.MODULE_ID, rma.getModuleId());
        crit.add(ConditionPeer.ISSUE_TYPE_ID, rma.getIssueTypeId());
        crit.add(ConditionPeer.ATTRIBUTE_ID, rma.getAttributeId());
        ConditionPeer.doDelete(crit);
        BaseTransitionPeer.doDelete(crit);
    }
              
// in java/org/tigris/scarab/om/AttributeOptionPeer.java
public static List getSortedAttributeOptions() throws TorqueException 
    {
      List attributeOptions = null;
      final Criteria crit = new Criteria();
      crit.addAscendingOrderByColumn(AttributeOptionPeer.ATTRIBUTE_ID);
      crit.addAscendingOrderByColumn(AttributeOptionPeer.OPTION_ID);
      attributeOptions = doSelect(crit);
      attributeOptions.remove(0);
      return attributeOptions;  
    }
              
// in java/org/tigris/scarab/om/AttributeOptionPeer.java
public static List<AttributeOption> getSortedAttributeOptions(Module module) throws TorqueException 
    {
        List<Integer> rmaIds = RModuleAttribute.getRMAIds(module.getModuleId());
        //List<Integer> rmoIds = RModuleOption.getRMOIds(module.getModuleId());
        List<AttributeOption> attributeOptions = null;
        final Criteria crit = new Criteria();
      
        //SELECT * FROM scarab_attribute_option s where attribute_id in (select distinct attribute_id from scarab_r_module_attribute where module_id=10001);
        crit.addIn(AttributeOptionPeer.ATTRIBUTE_ID,rmaIds);
        crit.add(AttributeOptionPeer.DELETED,0);
        crit.addAscendingOrderByColumn(AttributeOptionPeer.ATTRIBUTE_ID);
        crit.addAscendingOrderByColumn(AttributeOptionPeer.OPTION_ID);
        attributeOptions = (List<AttributeOption>)doSelect(crit);
        //attributeOptions.remove(0);
        return attributeOptions;  
    }
              
// in java/org/tigris/scarab/om/RQueryUser.java
public void delete(ScarabUser user) throws TorqueException
                                                             
    { 
        if (user.getUserId().equals(getUserId()))
        {
            Criteria c = new Criteria()
                .add(RQueryUserPeer.USER_ID, getUserId())
                .add(RQueryUserPeer.QUERY_ID, getQueryId());
            RQueryUserPeer.doDelete(c);
        }
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public AttributeOption getChildOption()
        throws TorqueException
    {
        return AttributeOptionManager.getInstance(getOptionId());
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public AttributeOption getParentOption()
        throws TorqueException
    {
        return AttributeOptionManager.getInstance(getParentId());
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public List getAncestors()
        throws TorqueException, Exception
    {
        ancestors = new ArrayList();
        AttributeOption parent = getParentOption();
        if (!ROOT_ID.equals(parent.getOptionId()))
        {
            addAncestors(parent);
        }
        return ancestors;
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
private void addAncestors(AttributeOption option)
        throws TorqueException, Exception
    {
        if (!ROOT_ID.equals(option.getParent().getOptionId()))
        {
            if (ancestors.contains(option.getParent()))
            {
                throw new TorqueException("Tried to add a recursive parent-child " +
                                    "attribute option relationship."); //EXCEPTION
            }
            else
            { 
                addAncestors(option.getParent());
            }
        }
        ancestors.add(option.getOptionId());
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public void save()
        throws TorqueException, ScarabException
    {
        AttributeOption ao = null;
        ROptionOption roo = null;

        final Attribute tmpAttr = AttributeManager.getInstance(getAttributeId());
        
        // if it is new, it won't already have an optionId
        if (getOptionId() == null)
        {
            // if it is new, check for duplicates.
            final AttributeOption duplicate = 
                AttributeOptionManager.getInstance(tmpAttr, getName().trim());
            final AttributeOption parent = 
                AttributeOptionManager.getInstance(getParentId());
            if (duplicate != null)
            {
                throw new ScarabException (new L10NKey("CannotCreateDuplicateOption")); //EXCEPTION
            }
            else if (parent.getDeleted())
            {
                throw new ScarabException (new L10NKey("CannotCreateChild")); //EXCEPTION
            }
        }

        // if getOptionId() is null, then it will just create a new instance
        final Integer optionId = getOptionId();
        if (optionId == null)
        {
            ao = AttributeOptionManager.getInstance();
        } 
        else
        {
            ao = AttributeOptionManager.getInstance(getOptionId());
        }

        
        ao.setName(getName());
        ao.setDeleted(getDeleted());
        ao.setAttribute(tmpAttr);
        ao.setStyle(getStyle());
        ao.save();

        // clean out the caches for the AO
        tmpAttr.doRemoveCaches();

        // now set our option id from the saved AO
        this.setOptionId(ao.getOptionId());

        // now create the ROO mapping
        try
        {
            // look for a cached ROptionOption
            roo = ROptionOption.getInstance(getParentId(), getOptionId());
        }
        catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
        roo.setPreferredOrder(getPreferredOrder());
        roo.setWeight(getWeight());
        roo.setRelationshipId(OptionRelationship.PARENT_CHILD);
        roo.save();
    }
              
// in java/org/tigris/scarab/om/AttributeGroupPeer.java
public static AttributeGroup retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        AttributeGroup result = null;
        Object obj = ScarabCache.get(ATTRIBUTEGROUP_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseAttributeGroupPeer.retrieveByPK(pk);
            ScarabCache.put(result, ATTRIBUTEGROUP_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (AttributeGroup)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributeOptionManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttributeOptionPeer.OPTION_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/AttributeOptionManager.java
public static AttributeOption getInstance(final Attribute attribute, 
            final String name)
        throws TorqueException
    {
        return getInstance(attribute, name, (Module) null, (IssueType) null);
    }
              
// in java/org/tigris/scarab/om/AttributeOptionManager.java
public static AttributeOption getInstance(final Attribute attribute, 
                                              final String name,
                                              final Module module,
                                              final IssueType issueType)
        throws TorqueException
    {
        AttributeOption ao = null;
        Criteria crit;
        // FIXME: Optimize this implementation!  It is grossly
        // inefficient, which is problematic given how often it may be
        // used.
        if (module != null && issueType != null)
        {
            // Look for a module-scoped alias.
            crit = new Criteria(4);
            crit.add(AttributeOptionPeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId());
            crit.addJoin(AttributeOptionPeer.OPTION_ID, 
                         RModuleOptionPeer.OPTION_ID); 
            crit.add(RModuleOptionPeer.MODULE_ID, module.getModuleId());
            crit.add(RModuleOptionPeer.ISSUE_TYPE_ID,
                     issueType.getIssueTypeId());
            crit.add(RModuleOptionPeer.DISPLAY_VALUE, name);
            final List rmos = RModuleOptionPeer.doSelect(crit);
            if (rmos.size() == 1)
            {
                final RModuleOption rmo = (RModuleOption) rmos.get(0);
                ao = rmo.getAttributeOption();
            }
        }

        if (ao == null)
        {
            // TODO It seems that we might not necessarily get the global option.
            // Do we want to add a criteria to limit to getting the global option?
            // This would be either "= 0" or "is null".
             
            crit = new Criteria(2);
            crit.add(AttributeOptionPeer.OPTION_NAME, name);
            crit.add(AttributeOptionPeer.ATTRIBUTE_ID,
                     attribute.getAttributeId());
            crit.setIgnoreCase(true);
            final List options = AttributeOptionPeer.doSelect(crit);
            if (options.size() == 1)
            {
                ao =  (AttributeOption) options.get(0);
            }
        }
        return ao;
    }
              
// in java/org/tigris/scarab/om/IssueTypeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(IssueTypePeer.ISSUE_TYPE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/ROptionOption.java
public static void doRemove(ROptionOption roo)
        throws TorqueException
    {
        // using Criteria because there is a bug in Torque
        // where doDelete(roo) doesn't work because it has
        // multple primary keys
        Criteria crit = new Criteria();
        crit.add (ROptionOptionPeer.OPTION1_ID, roo.getOption1Id());
        crit.add (ROptionOptionPeer.OPTION2_ID, roo.getOption2Id());

        ROptionOptionPeer.doDelete(crit);
    }
              
// in java/org/tigris/scarab/om/ROptionOption.java
public static void doRemove(Integer parent, Integer child)
        throws TorqueException
    {
        ROptionOption roo = getInstance();
        roo.setOption1Id(parent);
        roo.setOption2Id(child);
        ROptionOption.doRemove(roo);
    }
              
// in java/org/tigris/scarab/om/ROptionOption.java
public AttributeOption getOption1Option()
        throws TorqueException
    {
        return AttributeOptionManager.getInstance(getOption1Id());
    }
              
// in java/org/tigris/scarab/om/ROptionOption.java
public AttributeOption getOption2Option()
        throws TorqueException
    {
        return AttributeOptionManager.getInstance(getOption2Id());
    }
              
// in java/org/tigris/scarab/om/FrequencyPeer.java
public static List getFrequencies() throws TorqueException
    {
        return doSelect(new Criteria());
    }
              
// in java/org/tigris/scarab/om/UserPreference.java
public void save() throws TorqueException
    {
        if (!this.getScarabUser().isUserAnonymous())
        {
            super.save();
        }
    }
              
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
public void delete(final ScarabUser user) throws TorqueException, TurbineSecurityException 
    { 
        boolean hasPermission = true;
        if (getModule() != null)
        {
            hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,getModule());
        }
        else //getModule() is null for X Project queries, so get the modules from the MIT List
        {
            final List moduleList = user.getCurrentMITList().getModules();
            for (Iterator iter = moduleList.iterator(); iter.hasNext(); )
            {
                hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,(Module)iter.next());
                if (!hasPermission)
                {
                    break;
                }
            }
        }
        if (hasPermission)
        {
            final Criteria c = new Criteria()
                .add(RModuleUserAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleUserAttributePeer.LIST_ID, getListId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleUserAttributePeer.doDelete(c);
        }
        else
        {
            throw new TurbineSecurityException(ScarabConstants.NO_PERMISSION_MESSAGE); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValueManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttributeValuePeer.ISSUE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/ActivitySetType.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException, ScarabException
    {
        return ActivitySetTypeManager.getInstance(activitySetTypeName);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImplPeer.java
public static int getUsersCount(final Criteria critCount) 
        throws TorqueException, DataSetException
    {
        final List resultCount = ScarabUserImplPeer.doSelectVillageRecords(critCount);
        final Record record = (Record) resultCount.get(0);                
        return record.getValue(1).asInt();        
    }
              
// in java/org/tigris/scarab/om/IssuePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
              
// in java/org/tigris/scarab/om/IssuePeer.java
public static int countDistinct(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT_DISTINCT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
              
// in java/org/tigris/scarab/om/IssuePeer.java
public static Issue retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        Issue result = null;
        Object obj = ScarabCache.get(ISSUE_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseIssuePeer.retrieveByPK(pk);
            ScarabCache.put(result, ISSUE_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (Issue)obj;
        }
        
        result = BaseIssuePeer.retrieveByPK(pk);
        return result;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public String getPort() 
        throws TorqueException
    {
        if (port == null)
        {
            port = GlobalParameterManager
                    .getString(ScarabConstants.HTTP_PORT);
        }
        return port;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public String getScheme() 
        throws TorqueException
    {
        if (scheme == null)
        {
            scheme = GlobalParameterManager
                    .getString(ScarabConstants.HTTP_SCHEME);
        }
        return scheme;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public String getScriptName() 
        throws TorqueException
    {
        if (scriptName == null)
        {
            scriptName = GlobalParameterManager
                    .getString(ScarabConstants.HTTP_SCRIPT_NAME);
        }
        return scriptName;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public ScarabPaginatedList getUsers(final String name, 
                                        final String username, 
                                        final MITList mitList, 
                                        final int pageNum, 
                                        final int resultsPerPage,
                                        final String sortColumn, 
                                        final String sortPolarity,
                                        final boolean includeCommitters)
        throws TorqueException, DataSetException
    {
    	return getUsers(name, username, mitList, pageNum, resultsPerPage, sortColumn, sortPolarity, includeCommitters, false);
    	
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public ScarabPaginatedList getUsers(final String name, 
                                        final String username, 
                                        final MITList mitList, 
                                        final int pageNum, 
                                        final int resultsPerPage,
                                        final String sortColumn, 
                                        final String sortPolarity,
                                        final boolean includeCommitters,
                                        final boolean confirmedOnly)
        throws TorqueException, DataSetException
    {
        final int polarity = sortPolarity.equals("asc") ? 1 : -1; 
        List result = null;
        ScarabPaginatedList paginated = null; 

        final Comparator c = new Comparator() 
        {
            public int compare(Object o1, Object o2) 
            {
                int i = 0;
                if ("username".equals(sortColumn))
                {
                    i =  polarity * ((ScarabUser)o1).getUserName()
                              .compareTo(((ScarabUser)o2).getUserName());
                }
                else
                {
                    i =  polarity * ((ScarabUser)o1).getName()
                             .compareTo(((ScarabUser)o2).getName());
                }
                return i;
             }
        };

            final Criteria crit = new Criteria();//
            final Criteria critCount = new Criteria();
            critCount.addSelectColumn("COUNT(DISTINCT " + TurbineUserPeer.USERNAME + ")");
            if (mitList != null)
            {
                final List modules = mitList.getModules();
                for (Iterator it = modules.iterator(); it.hasNext(); )
                {
                    final Module mod = (Module)it.next();
                    final List perms = mitList.getUserAttributePermissions();
                    if (includeCommitters && !perms.contains(org.tigris.scarab.services.security.ScarabSecurity.ISSUE__ENTER))
                    {
                        perms.add(org.tigris.scarab.services.security.ScarabSecurity.ISSUE__ENTER);
                    }

                    crit.addIn(TurbinePermissionPeer.PERMISSION_NAME, perms);
                    crit.setDistinct();
                    critCount.addIn(TurbinePermissionPeer.PERMISSION_NAME, perms);
                }
                crit.addIn(TurbineUserGroupRolePeer.GROUP_ID, mitList.getModuleIds());
                critCount.addIn(TurbineUserGroupRolePeer.GROUP_ID, mitList.getModuleIds());
            }
            crit.addJoin(TurbineUserPeer.USER_ID, TurbineUserGroupRolePeer.USER_ID);
            crit.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePermissionPeer.ROLE_ID);
            crit.addJoin(TurbineRolePermissionPeer.PERMISSION_ID, TurbinePermissionPeer.PERMISSION_ID);
            critCount.addJoin(TurbineUserPeer.USER_ID, TurbineUserGroupRolePeer.USER_ID);
            critCount.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePermissionPeer.ROLE_ID);
            critCount.addJoin(TurbineRolePermissionPeer.PERMISSION_ID, TurbinePermissionPeer.PERMISSION_ID);            

			//user by name
            if (name != null)
            {
                int nameSeparator = name.indexOf(" ");
                if (nameSeparator != -1) 
                {
                    final String firstName = name.substring(0, nameSeparator);
                    final String lastName = name.substring(nameSeparator+1, name.length());
                    crit.add(ScarabUserImplPeer.FIRST_NAME, 
                             addWildcards(firstName), Criteria.LIKE);
                    crit.add(ScarabUserImplPeer.LAST_NAME, 
                             addWildcards(lastName), Criteria.LIKE);
                    critCount.add(ScarabUserImplPeer.FIRST_NAME, 
                            addWildcards(firstName), Criteria.LIKE);
                    critCount.add(ScarabUserImplPeer.LAST_NAME, 
                            addWildcards(lastName), Criteria.LIKE);
                    
                }
                else 
                {
                    String[] tableAndColumn = StringUtils.split(ScarabUserImplPeer.FIRST_NAME, ".");
                    final Criteria.Criterion fn = crit.getNewCriterion(tableAndColumn[0],
                                                                 tableAndColumn[1], 
                                                                 addWildcards(name), 
                                                                 Criteria.LIKE);
                    tableAndColumn = StringUtils.split(ScarabUserImplPeer.LAST_NAME, ".");
                    final Criteria.Criterion ln = crit.getNewCriterion(tableAndColumn[0],
                                                                 tableAndColumn[1], 
                                                                 addWildcards(name), 
                                                                 Criteria.LIKE);
                    fn.or(ln);
                    crit.add(fn);
                    critCount.add(fn);
                }
            }

            if (username != null)
            {
                crit.add(ScarabUserImplPeer.LOGIN_NAME, 
                         addWildcards(username), Criteria.LIKE);
                critCount.add(ScarabUserImplPeer.LOGIN_NAME, 
                        addWildcards(username), Criteria.LIKE);
            }
            
            String col = ScarabUserImplPeer.FIRST_NAME;
            if (sortColumn.equals("username"))
                col = ScarabUserImplPeer.USERNAME;
            if (sortPolarity.equals("asc"))
            {
                crit.addAscendingOrderByColumn(col);
            }
            else
            {
                crit.addDescendingOrderByColumn(col);
            }
            
            //confirmed users only
            if(confirmedOnly){
            	crit.add(ScarabUserImplPeer.CONFIRM_VALUE, (Object)"CONFIRMED", Criteria.EQUAL);
            }

			//finish query
            final int totalResultSize = ScarabUserImplPeer.getUsersCount(critCount);
            
            crit.setOffset((pageNum - 1)* resultsPerPage);
            crit.setLimit(resultsPerPage);
            result = ScarabUserImplPeer.doSelect(crit);

            // if there are results, sort the result set
            if (totalResultSize > 0 && resultsPerPage > 0)
            {

                paginated = new ScarabPaginatedList(result, totalResultSize,
                                                    pageNum,
                                                    resultsPerPage);
            }
            else 
            {
                paginated = new ScarabPaginatedList();
            }
        
        return paginated;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public List getUsers(String firstName, String lastName, 
                         String username, String email, IssueType issueType)
        throws TorqueException
    {
        List result = null;
        Serializable[] keys = {this, GET_USERS, firstName, lastName, 
                               username, email, issueType};
        Object obj = ScarabCache.get(keys); 
        if (obj == null) 
        {
            ScarabUser[] eligibleUsers = getUsers(getUserPermissions(issueType));
            if (eligibleUsers == null || eligibleUsers.length == 0) 
            {
                result = Collections.EMPTY_LIST;
            }
            else 
            {
                List userIds = new ArrayList();
                for (int i = 0; i < eligibleUsers.length; i++)
                {
                    userIds.add(eligibleUsers[i].getUserId());
                }
                Criteria crit = new Criteria();
                crit.addIn(ScarabUserImplPeer.USER_ID, userIds);
                
                if (firstName != null)
                {
                    crit.add(ScarabUserImplPeer.FIRST_NAME, 
                             addWildcards(firstName), Criteria.LIKE);
                }
                if (lastName != null)
                {
                    crit.add(ScarabUserImplPeer.LAST_NAME, 
                             addWildcards(lastName), Criteria.LIKE);
                }
                if (username != null)
                {
                    crit.add(ScarabUserImplPeer.LOGIN_NAME, 
                             addWildcards(username), Criteria.LIKE);
                }
                if (email != null)
                {
                    crit.add(ScarabUserImplPeer.EMAIL, addWildcards(email), 
                             Criteria.LIKE);
                }
                result = ScarabUserImplPeer.doSelect(crit);
            }
            ScarabCache.put(result, keys);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void setParent(Module v)
        throws TorqueException
    {
        super.setModuleRelatedByParentId(v);
        // setting the name to be null so that 
        // it gets rebuilt with the new information
        setName(null);
        resetAncestors();
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public Module getParent()
        throws TorqueException
    {
        Module parent = super.getModuleRelatedByParentId();

        // The top level module has itself as parent.
        // Return null in this case, to avoid endless loops.
        if (this.getModuleId() == parent.getModuleId())
        {
            parent = null;
        }
        return parent;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void setParentId(Integer id)
        throws TorqueException
    {
        super.setParentId(id);
        // setting the name to be null so that 
        // it gets rebuilt with the new information
        setName(null);
        resetAncestors();
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public List getRModuleIssueTypes()
        throws TorqueException
    {
        return super.getRModuleIssueTypes("preferredOrder","asc");
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public int getIssueCount(ScarabUser user, AttributeOption attributeOption)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();

        Integer attributeId = attributeOption.getAttributeId();
        Integer optionId    = attributeOption.getOptionId();

        crit.add(AttributeValuePeer.ATTRIBUTE_ID, attributeId);
        crit.add(AttributeValuePeer.OPTION_ID,optionId);
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.MOVED, 0);
        crit.add(IssuePeer.DELETED, 0);
        crit.add(IssuePeer.ID_COUNT, 0, SqlEnum.GREATER_THAN);
        crit.addJoin(AttributeValuePeer.ISSUE_ID, IssuePeer.ISSUE_ID);
        crit.add(AttributeValuePeer.DELETED,0);
        int count = AttributeValuePeer.count(crit);
        return count;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public int getIssueCount(ScarabUser user)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.DELETED,0);
        crit.add(IssuePeer.MOVED,0);
        crit.add(IssuePeer.ID_COUNT, 0, SqlEnum.GREATER_THAN);
        int count = IssuePeer.count(crit);
        return count;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public List getRModuleAttributes(Criteria crit)
        throws TorqueException
    {
        return super.getRModuleAttributes(crit);
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public List getRModuleOptions(Criteria crit)
        throws TorqueException
    {
        crit.addJoin(RModuleOptionPeer.OPTION_ID, 
                     AttributeOptionPeer.OPTION_ID)
            .add(AttributeOptionPeer.DELETED, false);
        return super.getRModuleOptions(crit);
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public List getDuplicatesByNameAndParent(String realName, Integer parentId) throws TorqueException{
    	
    	final Criteria crit = new Criteria();
        crit.add(ScarabModulePeer.MODULE_NAME, realName);
        crit.add(ScarabModulePeer.PARENT_ID, parentId);
        return ScarabModulePeer.doSelect(crit);
        
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void save(final Connection dbCon) 
        throws TorqueException
    {
        // if new, make sure the code has a value.
        if (isNew())
        {

            List result;
            try {
                result = getDuplicatesByNameAndParent(getRealName(), getParentId());
            }
            catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
            if (result.size() > 0)
            {
                throw new ScarabLocalizedTorqueException(
                        new ScarabException(
                                L10NKeySet.ExceptionModuleAllreadyExists,
                        getRealName(), 
                        getParent().getName()));
            }

            final String code = getCode();
            if (code == null || code.length() == 0)
            {
                if (getParentId().equals(ROOT_ID))
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionTopLevelModuleWithoutCode));
                }

                try
                {
                    setCode(getParent().getCode());
                }
                catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            }

            // need to do this before the relationship save below
            // in order to set the moduleid for the new module.
            super.save(dbCon);
            try
            {
                dbCon.commit();
            }
            catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
            if (getOwnerId() == null) 
            {
                throw new ScarabLocalizedTorqueException(new  ScarabException(L10NKeySet.ExceptionSaveNeedsOwner));
            }
            // grant the ower of the module the Project Owner role
            try
            {
                final User user = ScarabUserManager.getInstance(getOwnerId());
 
                final Role role = TurbineSecurity.getRole(PROJECT_OWNER_ROLE);
                grant (user, role);
                setInitialAttributesAndIssueTypes();
            }
            catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
        }
        else
        {
            super.save(dbCon);
        }
        
        // clear out the cache beause we want to make sure that
        // things get updated properly.
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public List getNotDeletedModuleReports() 
        throws TorqueException
    {
        return ReportManager.getManager().getNotDeletedModuleReports(this);
    }
              
// in java/org/tigris/scarab/om/NotificationStatus.java
public ScarabUser getCreator() throws TorqueException
    {
        Integer id = this.getCreatorId();
        ScarabUser user = ScarabUserManager.getInstance(id);
        return user;
    }
              
// in java/org/tigris/scarab/om/NotificationStatus.java
public ScarabUser getReceiver() throws TorqueException
    {
        Integer id = this.getReceiverId();
        ScarabUser user = ScarabUserManager.getInstance(id);
        return user;
    }
              
// in java/org/tigris/scarab/om/NotificationStatus.java
public void delete() throws TorqueException
    {
        Criteria crit = new Criteria();
        crit
                .add(NotificationStatusPeer.ACTIVITY_ID, this
                        .getActivityId());
        crit.add(NotificationStatusPeer.CREATOR_ID, this.getCreatorId());
        crit.add(NotificationStatusPeer.RECEIVER_ID, this.getReceiverId());
        NotificationStatusPeer.doDelete(crit);
    }
              
// in java/org/tigris/scarab/om/NotificationStatus.java
public void markDeleted() throws TorqueException
    {
        this.setStatus(MARK_DELETED);
        this.setChangeDate(new Date());
        this.save();
    }
              
// in java/org/tigris/scarab/om/Transition.java
public boolean isRequiredIf(Integer optionID) throws TorqueException
    {
        Condition cond = new Condition();
        cond.setAttributeId(null);
        cond.setOptionId(optionID);
        cond.setModuleId(null);
        cond.setIssueTypeId(null);
        cond.setTransitionId(this.getTransitionId());
        return this.getConditions().contains(cond);
    }
              
// in java/org/tigris/scarab/om/Transition.java
public List<Condition> getConditions() throws TorqueException
    {
    	List<Condition> conds = (List<Condition>)TransitionManager.getMethodResult().get(this, "getConditions");
    	if (conds == null)
    	{
        	conds = super.getConditions();
        	TransitionManager.getMethodResult().put(conds, this, "getConditions");
    	}
    	return conds;
    }
              
// in java/org/tigris/scarab/om/Transition.java
public void setConditionsArray(Integer aOptionId[], Integer operator) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.ATTRIBUTE_ID, null);
        crit.add(ConditionPeer.MODULE_ID, null);
        crit.add(ConditionPeer.ISSUE_TYPE_ID, null);
        crit.add(ConditionPeer.TRANSITION_ID, this.getTransitionId());
        ConditionPeer.doDelete(crit);
        this.getConditions().clear();
        ConditionManager.clear();
        if (aOptionId != null)
        {
	        for (int i=0; i<aOptionId.length; i++)
	        {
	            if (aOptionId[i].intValue() != 0)
	            {
		            Condition cond = new Condition();
		            cond.setTransitionId(this.getTransitionId());
		            cond.setOptionId(aOptionId[i]);
		            cond.setAttributeId(null);
		            cond.setModuleId(null);
		            cond.setIssueTypeId(null);
		            cond.setOperator(operator);
		            this.addCondition(cond);
		            cond.save();
	            }
	        }
        }
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public IssueType getTemplateIssueType()
        throws TorqueException, ScarabException
    {
        if (templateIssueType == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.PARENT_ID, getIssueTypeId());
            final List results = IssueTypePeer.doSelect(crit);
            if (results.isEmpty())
            {
                throw new ScarabException(L10NKeySet.ExceptionTemplateTypeForIssueType);
            }
            else
            {
                templateIssueType = (IssueType)results.get(0);
            }
        }
        return templateIssueType;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public IssueType getIssueTypeForTemplateType()
        throws TorqueException
    {
        if (parentIssueType == null) 
        {        
            parentIssueType = getIssueTypeRelatedByParentId();
        }
        return parentIssueType;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public Integer getTemplateId()
        throws TorqueException, ScarabException
    {
        return getTemplateIssueType().getIssueTypeId();
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public boolean hasIssues()
        throws TorqueException, DataSetException
    {
        return hasIssues((Module) null);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public String getDisplayName(Module module)
        throws TorqueException
    {
        String moduleName = module.getRModuleIssueType(this).getDisplayName();
        String displayName = getName();
        if (!moduleName.equals(displayName))
        {
            displayName = moduleName +" (" + displayName + ")";
        }
        return displayName;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public boolean hasIssues(Module module)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();
        crit.add(IssuePeer.TYPE_ID, getIssueTypeId());
        if (module != null)
        {
            crit.add(IssuePeer.MODULE_ID, module.getModuleId());
        }
        return (IssuePeer.count(crit) > 0);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public static IssueType getInstance(final String issueTypeName)
        throws TorqueException,ScarabException
    {
        IssueType result = null;
        Object obj = ScarabCache.get(ISSUE_TYPE, GET_INSTANCE, issueTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.NAME, issueTypeName);
            final List issueTypes = IssueTypePeer.doSelect(crit);
            if(issueTypes == null || issueTypes.size() == 0)
            {
                throw new ScarabException(L10NKeySet.ExceptionInvalidIssueType,
                                          issueTypeName);
            }
            result = (IssueType)issueTypes.get(0);
            ScarabCache.put(result, ISSUE_TYPE, GET_INSTANCE, issueTypeName);
        }
        else 
        {
            result = (IssueType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public IssueType copyIssueType()
        throws TorqueException, ScarabException
    {
        final IssueType newIssueType = new IssueType();
        newIssueType.setName(getName() + " (copy)");
        newIssueType.setDescription(getDescription());
        newIssueType.setParentId(ScarabConstants.INTEGER_0);
        newIssueType.save();
        final Integer newId = newIssueType.getIssueTypeId();

        // Copy template type
        final IssueType template = IssueTypePeer
              .retrieveByPK(getTemplateId());
        final IssueType newTemplate = new IssueType();
        newTemplate.setName(template.getName());
        newTemplate.setParentId(newId);
        newTemplate.save();

        // Copy user attributes
        final List userRIAs = getRIssueTypeAttributes(false, USER);
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            final RIssueTypeAttribute newUserRia = userRia.copyRia();
            newUserRia.setIssueTypeId(newId);
            newUserRia.save();
        }

        // Copy attribute groups
        final List attrGroups = getAttributeGroups(false);
        for (int i = 0; i<attrGroups.size(); i++)
        {
            final AttributeGroup group = (AttributeGroup)attrGroups.get(i);
            final AttributeGroup newGroup = group.copyGroup();
            newGroup.setIssueTypeId(newId);
            newGroup.save();

            // add attributes
            final List attrs = group.getAttributes();
            if (attrs != null)
            {
                for (int j=0; j<attrs.size(); j++)
                {
                    // save attribute-attribute group maps
                    final Attribute attr = (Attribute)attrs.get(j);
                    final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                    final RAttributeAttributeGroup newRaag = new RAttributeAttributeGroup();
                    newRaag.setAttributeId(raag.getAttributeId());
                    newRaag.setOrder(raag.getOrder());
                    newRaag.setGroupId(newGroup.getAttributeGroupId());
                    newRaag.save();

                    // save attribute-issueType maps
                    final RIssueTypeAttribute ria = getRIssueTypeAttribute(attr);
                    final RIssueTypeAttribute newRia = ria.copyRia();
                    newRia.setIssueTypeId(newId);
                    newRia.save();

                    // save options
                    final List rios = getRIssueTypeOptions(attr, false);
                    if (rios != null)
                    {
                        for (int k=0; k<rios.size(); k++)
                        {
                            final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                            final RIssueTypeOption newRio = rio.copyRio();
                            newRio.setIssueTypeId(newId);
                            newRio.save();
                        }
                    }
                }
            }
        }

        // add workflow 
        WorkflowFactory.getInstance().copyIssueTypeWorkflows(this, newIssueType);

        return newIssueType;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public void deleteModuleMappings(final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                 getIssueTypeId());
        final List rmits = RModuleIssueTypePeer.doSelect(crit);
        for (int i=0; i<rmits.size(); i++)
        {
            final RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
            rmit.delete(user);
        }
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public void createDefaultGroups()
        throws TorqueException
    {
        AttributeGroup ag = createNewGroup();
        ag.setOrder(1);
        ag.setDedupe(true);
        ag.setDescription(null);
        ag.save();
        AttributeGroup ag2 = createNewGroup();
        ag2.setOrder(3);
        ag2.setDedupe(false);
        ag2.setDescription(null);
        ag2.save();
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getAttributeGroups(Module module)
        throws TorqueException
    {
        return getAttributeGroups(module, false);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getAttributeGroups(boolean activeOnly)
        throws TorqueException
    {
        return getAttributeGroups(null, activeOnly);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getAttributeGroups(Module module, boolean activeOnly)
        throws TorqueException
    {
        List groups = null;
        Boolean activeBool = activeOnly ? Boolean.TRUE : Boolean.FALSE;
        Object obj = getMethodResult().get(this, GET_ATTRIBUTE_GROUPS,
                                           module, activeBool);
        if (obj == null)
        {
            Criteria crit = new Criteria()
                .add(AttributeGroupPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .addAscendingOrderByColumn(AttributeGroupPeer.PREFERRED_ORDER);
            if (activeOnly)
            {
                crit.add(AttributeGroupPeer.ACTIVE, true);
            }
            if (module != null)
            {
                crit.add(AttributeGroupPeer.MODULE_ID, module.getModuleId());
            }
            else
            {
                // TODO Change this to be crit.add(AttributeGroupPeer.MODULE_ID, Criteria.ISNULL) when torque is fixed
                crit.add(AttributeGroupPeer.MODULE_ID,
                         (Object)(AttributeGroupPeer.MODULE_ID + " IS NULL"),
                         Criteria.CUSTOM);
            }
            groups = AttributeGroupPeer.doSelect(crit);
            getMethodResult().put(groups, this, GET_ATTRIBUTE_GROUPS,
                                  module, activeBool);
        }
        else
        {
            groups = (List)obj;
        }
        return groups;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public AttributeGroup createNewGroup()
        throws TorqueException
    {
        return createNewGroup(null);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public AttributeGroup createNewGroup(Module module)
        throws TorqueException
    {
        List groups = getAttributeGroups(module, false);
        AttributeGroup ag = new AttributeGroup();

        // Make default group name 'new attribute group' 
        ag.setName(Localization.getString("ScarabBundle",
                ScarabConstants.DEFAULT_LOCALE, "NewAttributeGroup"));
        ag.setActive(true);
        ag.setIssueTypeId(getIssueTypeId());
        if (module != null)
        {
            ag.setModuleId(module.getModuleId());
        }
        if (groups.size() == 0)
        {
            ag.setDedupe(true);
            ag.setOrder(groups.size() +1);
        }
        else 
        {
            ag.setDedupe(false);
            ag.setOrder(groups.size() +2);
        }
        ag.save();
        groups.add(ag);
        return ag;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public int getDedupeSequence()
        throws TorqueException
    {
        return getDedupeSequence(null);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
int getDedupeSequence(Module module)
        throws TorqueException
    {
        List groups = getAttributeGroups(module, false);
        int sequence = groups.size() + 1;
        for (int i = 1; i <= groups.size(); i++)
        {
            int order;
            int previousOrder;
            try
            {
                order = ((AttributeGroup) groups.get(i)).getOrder();
                previousOrder = ((AttributeGroup) groups.get(i - 1)).getOrder();
            }
            catch (Exception e)
            {
                Log.get().warn("Error accessing dedupe sequence for issue "
                               + "type '" + this + '\'', e);
                return sequence;
            }

            if (order != previousOrder + 1)
            {
                sequence = order - 1;
                break;
            }
        }
        return sequence;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getRIssueTypeAttributes(boolean activeOnly)
        throws TorqueException
    {
        return getRIssueTypeAttributes(activeOnly, "all");
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getRIssueTypeAttributes(boolean activeOnly,
                                        String attributeType)
        throws TorqueException
    {
        List rias = null;
        Boolean activeBool = (activeOnly ? Boolean.TRUE : Boolean.FALSE);
        Object obj = getMethodResult().get(this, GET_R_ISSUETYPE_ATTRIBUTES, 
                                           activeBool, attributeType); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, 
                     getIssueTypeId());
            crit.addAscendingOrderByColumn(
                RIssueTypeAttributePeer.PREFERRED_ORDER);
            
            if (activeOnly)
            {
                crit.add(RIssueTypeAttributePeer.ACTIVE, true);
            }
            
            if (USER.equals(attributeType))
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY);
                crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                         RIssueTypeAttributePeer.ATTRIBUTE_ID); 
            }
            else if (NON_USER.equals(attributeType))
            {
                crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                         RIssueTypeAttributePeer.ATTRIBUTE_ID); 
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY,
                         Criteria.NOT_EQUAL);
            }
            
            rias = RIssueTypeAttributePeer.doSelect(crit); 
            getMethodResult().put(rias, this, GET_R_ISSUETYPE_ATTRIBUTES, 
                                  activeBool, attributeType);
        }
        else 
        {
            rias = (List)obj;
        }
        return rias;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getAttributes(String attributeType)
        throws TorqueException
    {
        ArrayList attrs = new ArrayList();
        List rias = getRIssueTypeAttributes(true, attributeType);
        for (int i=0; i<rias.size(); i++)
        {
            attrs.add(((RIssueTypeAttribute)rias.get(i)).getAttribute());
        }
        return attrs;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public RIssueTypeAttribute addRIssueTypeAttribute(Attribute attribute)
        throws TorqueException
    {
        String attributeType = null;
        attributeType = (attribute.isUserAttribute() ? USER : NON_USER);

        RIssueTypeAttribute ria = new RIssueTypeAttribute();
        ria.setIssueTypeId(getIssueTypeId());
        ria.setAttributeId(attribute.getAttributeId());
        ria.setOrder(getLastAttribute(attributeType) + 1);
        ria.save();
        getRIssueTypeAttributes(false, attributeType).add(ria);
        return ria;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public RIssueTypeAttribute getRIssueTypeAttribute(Attribute attribute)
        throws TorqueException
    {
        RIssueTypeAttribute ria = null;
        List rias = null;
        if (attribute.isUserAttribute())
        {
            rias = getRIssueTypeAttributes(false, USER);
        }
        else
        {
            rias = getRIssueTypeAttributes(false, NON_USER);
        }
        Iterator i = rias.iterator();
        while (i.hasNext())
        {
            RIssueTypeAttribute tempRia = (RIssueTypeAttribute)i.next();
            if (tempRia.getAttribute().equals(attribute))
            {
                ria = tempRia;
                break;
            }
        }
        return ria;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getUserAttributes()
        throws TorqueException
    {
        return getUserAttributes(true);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getUserAttributes(boolean activeOnly)
        throws TorqueException
    {
        List rIssueTypeAttributes = getRIssueTypeAttributes(activeOnly, USER);
        List userAttributes = new ArrayList();

        for (int i=0; i<rIssueTypeAttributes.size(); i++)
        {
            Attribute att = ((RIssueTypeAttribute)rIssueTypeAttributes.get(i)).getAttribute();
            userAttributes.add(att);
        }
        return userAttributes;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public int getLastAttribute(String attributeType)
        throws TorqueException
    {
        List itAttributes = getRIssueTypeAttributes(false, attributeType);
        int last = 0;

        for (int i=0; i<itAttributes.size(); i++)
        {
               int order = ((RIssueTypeAttribute) itAttributes.get(i))
                         .getOrder();
               if (order > last)
               {
                   last = order;
               }
        }
        return last;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public int getLastAttributeOption(Attribute attribute)
        throws TorqueException
    {
        List issueTypeOptions = getRIssueTypeOptions(attribute);
        int last = 0;

        for (int i=0; i<issueTypeOptions.size(); i++)
        {
               int order = ((RIssueTypeOption) issueTypeOptions.get(i))
                         .getOrder();
               if (order > last)
               {
                   last = order;
               }
        }
        return last;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public RIssueTypeOption addRIssueTypeOption(AttributeOption option)
        throws TorqueException
    {
        RIssueTypeOption rio = new RIssueTypeOption();
        rio.setIssueTypeId(getIssueTypeId());
        rio.setOptionId(option.getOptionId());
        rio.setOrder(getLastAttributeOption(option.getAttribute()) + 1);
        rio.save();
        getRIssueTypeOptions(option.getAttribute(), false).add(rio);
        return rio;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getRIssueTypeOptions(Attribute attribute)
        throws TorqueException
    {
        return getRIssueTypeOptions(attribute, true);
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getRIssueTypeOptions(Attribute attribute, boolean activeOnly)
        throws TorqueException
    {
        List allRIssueTypeOptions = null;
        allRIssueTypeOptions = getAllRIssueTypeOptions(attribute);

        if (allRIssueTypeOptions != null)
        {
            if (activeOnly)
            {
                List activeRIssueTypeOptions =
                    new ArrayList(allRIssueTypeOptions.size());
                for (int i=0; i<allRIssueTypeOptions.size(); i++)
                {
                    RIssueTypeOption rio =
                        (RIssueTypeOption)allRIssueTypeOptions.get(i);
                    if (rio.getActive())
                    {
                        activeRIssueTypeOptions.add(rio);
                    }
                }
                allRIssueTypeOptions =  activeRIssueTypeOptions;
            }
        }
        return allRIssueTypeOptions;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
private List getAllRIssueTypeOptions(Attribute attribute)
        throws TorqueException
    {
        List rIssueTypeOpts;
        Object obj = ScarabCache.get(this, GET_ALL_R_ISSUETYPE_OPTIONS, 
                                     attribute); 
        if (obj == null) 
        {
            List options = attribute.getAttributeOptions(false);
            Integer[] optIds = null;
            if (options == null)
            {
                optIds = new Integer[0];
            }
            else
            {
                optIds = new Integer[options.size()];
            }
            for (int i=optIds.length-1; i>=0; i--)
            {
                optIds[i] = ((AttributeOption)options.get(i)).getOptionId();
            }
            
            if (optIds.length > 0)
            { 
                Criteria crit = new Criteria();
                crit.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId());
                crit.addIn(RIssueTypeOptionPeer.OPTION_ID, optIds);
                crit.addJoin(RIssueTypeOptionPeer.OPTION_ID, AttributeOptionPeer.OPTION_ID);
                crit.addAscendingOrderByColumn(RIssueTypeOptionPeer.PREFERRED_ORDER);
                crit.addAscendingOrderByColumn(AttributeOptionPeer.OPTION_NAME);
                rIssueTypeOpts = RIssueTypeOptionPeer.doSelect(crit);
            }
            else
            {
                rIssueTypeOpts = new ArrayList(0);
            }
            ScarabCache.put(rIssueTypeOpts, this, GET_ALL_R_ISSUETYPE_OPTIONS, 
                            attribute);
        }
        else 
        {
            rIssueTypeOpts = (List)obj;
        }
        return rIssueTypeOpts;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public RIssueTypeOption getRIssueTypeOption(AttributeOption option)
        throws TorqueException
    {
        RIssueTypeOption rio = null;
        List rios = getRIssueTypeOptions(option.getAttribute(), false);
        Iterator i = rios.iterator();
        while (i.hasNext())
        {
            rio = (RIssueTypeOption)i.next();
            if (rio.getAttributeOption().equals(option))
            {
                break;
            }
        }

        return rio;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getAvailableAttributes(String attributeType)
        throws TorqueException
    {
        List allAttributes = AttributePeer.getAttributes(attributeType);
        List availAttributes = new ArrayList();
        List rIssueTypeAttributes = getRIssueTypeAttributes(false,
                                                            attributeType);
        List attrs = new ArrayList();
        for (int i=0; i<rIssueTypeAttributes.size(); i++)
        {
            attrs.add(
               ((RIssueTypeAttribute) rIssueTypeAttributes.get(i)).getAttribute());
        }
        for (int i=0; i<allAttributes.size(); i++)
        {
            Attribute att = (Attribute)allAttributes.get(i);
            if (!attrs.contains(att))
            {
                availAttributes.add(att);
            }
        }
        return availAttributes;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getAvailableAttributeOptions(Attribute attribute)
        throws TorqueException
    {
        List rIssueTypeOptions = getRIssueTypeOptions(attribute, false);
        List issueTypeOptions = new ArrayList();
        if (rIssueTypeOptions != null)
        {
            for (int i=0; i<rIssueTypeOptions.size(); i++)
            {
                issueTypeOptions.add(
                   ((RIssueTypeOption) rIssueTypeOptions.get(i)).getAttributeOption());
            }
        }

        List allOptions = attribute.getAttributeOptions(false);
        List availOptions = new ArrayList();

        for (int i=0; i<allOptions.size(); i++)
        {
            AttributeOption option = (AttributeOption)allOptions.get(i);
            if (!issueTypeOptions.contains(option))
            {
                availOptions.add(option);
            }
        }
        return availOptions;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getMatchingAttributeValuesList(Module oldModule, Module newModule, 
                                               IssueType newIssueType)
          throws TorqueException
    {
        List matchingAttributes = new ArrayList();
        List srcActiveAttrs = getActiveAttributes(oldModule);
        List destActiveAttrs = newIssueType.getActiveAttributes(newModule);
        for (int i = 0; i<srcActiveAttrs.size(); i++)
        {
            Attribute attr = (Attribute)srcActiveAttrs.get(i);
                
            if (destActiveAttrs.contains(attr))
            {
                matchingAttributes.add(attr);
            } 
        }
        return matchingAttributes;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getOrphanAttributeValuesList(Module oldModule, Module newModule, 
                                             IssueType newIssueType)
          throws TorqueException
    {
        List orphanAttributes = new ArrayList();
        List srcActiveAttrs = getActiveAttributes(oldModule);
        List destActiveAttrs = newIssueType.getActiveAttributes(newModule);
        for (int i = 0; i<srcActiveAttrs.size(); i++)
        {
            Attribute attr = (Attribute)srcActiveAttrs.get(i);
            if (!destActiveAttrs.contains(attr))
            {
                orphanAttributes.add(attr);
            }
        }
        return orphanAttributes;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public boolean isSystemDefined()
        throws TorqueException
    {
        boolean systemDefined = false;
        String name = getName();
        if (name != null)
        {
            systemDefined = "system".equalsIgnoreCase(SYSTEM_CONFIG.getProperty(name));
        }
        return systemDefined;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public Attribute getDefaultTextAttribute(Module module)
        throws TorqueException
    {
        Attribute result = null;
        Object obj = ScarabCache.get(this, GET_DEFAULT_TEXT_ATTRIBUTE); 
        if (obj == null) 
        {        
            // get related RMAs
            Criteria crit = new Criteria()
                .add(RModuleAttributePeer.MODULE_ID, 
                     module.getModuleId());
            crit.addAscendingOrderByColumn(
                RModuleAttributePeer.PREFERRED_ORDER);
            List rmas = getRModuleAttributes(crit);
            
            // the code to find the correct attribute could be quite simple by
            // looping and calling RMA.isDefaultText().  The code from
            // that method can be restructured here to more efficiently
            // answer this question.
            Iterator i = rmas.iterator();
            while (i.hasNext()) 
            {
                RModuleAttribute rma = (RModuleAttribute)i.next();
                if (rma.getDefaultTextFlag()) 
                {
                    result = rma.getAttribute();
                    break;
                }
            }
            
            if (result == null) 
            {
                // locate the highest ranked text attribute
                i = rmas.iterator();
                while (i.hasNext()) 
                {
                    RModuleAttribute rma = (RModuleAttribute)i.next();
                    Attribute testAttr = rma.getAttribute();
                    if (testAttr.isTextAttribute() && 
                         getAttributeGroup(module, testAttr).getActive()) 
                    {
                        result = testAttr;
                        break;
                    }
                }
            }
            ScarabCache.put(result, this, GET_DEFAULT_TEXT_ATTRIBUTE);
        }
        else 
        {
            result = (Attribute)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getQuickSearchAttributes(Module module)
        throws TorqueException
    {
        List attributes = null;
        Object obj = ScarabCache.get(this, GET_QUICK_SEARCH_ATTRIBUTES, 
                                     module); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(3)
                .add(RModuleAttributePeer.QUICK_SEARCH, true);
            addOrderByClause(crit, module);
            attributes = getAttributes(crit);
            ScarabCache.put(attributes, this, GET_QUICK_SEARCH_ATTRIBUTES, 
                            module);
        }
        else 
        {
            attributes = (List)obj;
        }
        return attributes;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
private List getAttributes(final Criteria criteria)
        throws TorqueException
    {
        final List moduleAttributes = getRModuleAttributes(criteria);
        final List attributes = new ArrayList(moduleAttributes.size());
        for (int i=0; i<moduleAttributes.size(); i++)
        {
            attributes.add(
               ((RModuleAttribute) moduleAttributes.get(i)).getAttribute());
        }
        return attributes;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public boolean canCreateIssueInScope(ScarabUser user, Module module) throws TorqueException, ScarabException
    {
        //[HD first check, if user has IssueCreate permission in this module
        boolean isPermissionGranted = user.hasPermission(ScarabSecurity.ISSUE__ENTER, module);
        
        if(isPermissionGranted)
        {
            List requiredAttributes = getRequiredAttributes(module);
            Iterator iter = requiredAttributes.iterator();
            while(iter.hasNext())
            {
                Attribute attribute = (Attribute)iter.next();
                Workflow workflow = WorkflowFactory.getInstance();
                if(attribute.isOptionAttribute())
                {
                    boolean canDoPartial = workflow.canMakeTransitionsFrom(user, this, attribute, null);
                    if(!canDoPartial)
                    {
                        isPermissionGranted = false;
                        break;
                    }
                }
            }
        }
        return isPermissionGranted;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public boolean canCreateAttributeInScope(ScarabUser user, Module module, Attribute attribute) throws TorqueException, ScarabException
    {
        boolean result = true;
        Workflow workflow = WorkflowFactory.getInstance();
        if(attribute.isOptionAttribute())
        {
            result = workflow.canMakeTransitionsFrom(user, this, attribute, null);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List getRequiredAttributes(Module module)
        throws TorqueException
    {

        List attributes = null;
        Object obj = ScarabCache.get(this, GET_REQUIRED_ATTRIBUTES, 
                                     module); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(3)
                .add(RModuleAttributePeer.REQUIRED, true);
            crit.add(RModuleAttributePeer.ACTIVE, true);
            addOrderByClause(crit, module);
            List temp =  getAttributes(crit);
            List requiredAttributes  = new ArrayList();
            for (int i=0; i <temp.size(); i++)
            {
                Attribute att = (Attribute)temp.get(i);
                AttributeGroup group = getAttributeGroup(module, att);
                if (group != null && group.getActive())
                {
                    requiredAttributes.add(att);
                }
            }
            attributes = requiredAttributes;
            ScarabCache.put(attributes, this, GET_REQUIRED_ATTRIBUTES, 
                            module);
        }
        else 
        {
            attributes = (List)obj;
        }
        return attributes;

    }
              
// in java/org/tigris/scarab/om/IssueType.java
public List<Attribute> getActiveAttributes(final Module module)
        throws TorqueException
    {
        List attributes = null;
        Object obj = ScarabCache.get(this, GET_ACTIVE_ATTRIBUTES, module);
        if (obj == null)
        {
            final Criteria crit = new Criteria(2);
            crit.add(RModuleAttributePeer.ACTIVE, true);
            addOrderByClause(crit, module);
            attributes = getAttributes(crit);
            ScarabCache.put(attributes, this, GET_ACTIVE_ATTRIBUTES, 
                            module);
        }
        else
        {
            attributes = (List)obj;
        }
        return attributes;
    }
              
// in java/org/tigris/scarab/om/IssueType.java
private AttributeGroup getAttributeGroup(Module module, 
                                             Attribute attribute)
        throws TorqueException
    {
        AttributeGroup group = null;
        Object obj = ScarabCache.get(this, GET_ATTRIBUTE_GROUP, 
                                     module, attribute); 
        if (obj == null)
        {
            Criteria crit = new Criteria()
                .add(AttributeGroupPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(AttributeGroupPeer.MODULE_ID, 
                     module.getModuleId())
                .addJoin(RAttributeAttributeGroupPeer.GROUP_ID, 
                   AttributeGroupPeer.ATTRIBUTE_GROUP_ID)
                .add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId());
            List results = AttributeGroupPeer.doSelect(crit);
            if (results.size() > 0)
            {
                group = (AttributeGroup)results.get(0);
                ScarabCache.put(group, this, GET_ATTRIBUTE_GROUP, 
                                module, attribute);
            }
        }
        else 
        {
            group = (AttributeGroup)obj;
        }
        return group;
    }
              
// in java/org/tigris/scarab/om/RModuleAttributeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(RModuleAttributePeer.MODULE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/RModuleAttributeManager.java
public static final RModuleAttribute getInstance(Module module,  
        Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        SimpleKey[] keys = {
            SimpleKey.keyFor(module.getModuleId()),
            SimpleKey.keyFor(attribute.getAttributeId()),
            SimpleKey.keyFor(issueType.getIssueTypeId())
        };
        return getInstance(new ComboKey(keys));
    }
              
// in java/org/tigris/scarab/om/RModuleAttributeManager.java
public static final RModuleAttribute getInstance(Integer moduleId,  
        Integer attributeId, Integer issueTypeId)
        throws TorqueException
    {
        SimpleKey[] keys = {
            SimpleKey.keyFor(moduleId), 
            SimpleKey.keyFor(attributeId), 
            SimpleKey.keyFor(issueTypeId)
        };
        return getInstance(new ComboKey(keys));
    }
              
// in java/org/tigris/scarab/om/RModuleAttributeManager.java
static void removeInstanceFromCache(RModuleAttribute rma)
        throws TorqueException
    {
        RModuleAttributeManager thisManager = getManager();
        thisManager.removeInstanceImpl(rma.getPrimaryKey());
        List listeners = (List)thisManager.listenersMap
            .get(RModuleAttributePeer.MODULE_ID);
        thisManager.notifyListeners(listeners, rma, rma);
    }
              
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getSingleItemList(Module module, IssueType issueType,
                                            ScarabUser user)
        throws TorqueException
    {
        MITList list = getInstance();
        if (user != null) 
        {
            list.setScarabUser(user);
        }
        MITListItem item = MITListItemManager.getInstance();
        item.setModule(module);
        item.setIssueType(issueType);
        list.addMITListItem(item);
        return list;
    }
              
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getSingleModuleAllIssueTypesList(Module module,
                                                           ScarabUser user)
        throws TorqueException
    {
        MITList list = MITListManager.getInstance();
        list.setModifiable(false);
        list.setScarabUser(user);
        list.setName(Localization.format(ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         user.getLocale(),
                                         "AllIssueTypesCurrentModule", 
                                         module.getRealName()));
        
        MITListItem item = MITListItemManager.getInstance();
        item.setModule(module);
        item.setIssueTypeId(MITListItem.MULTIPLE_KEY);
        list.addMITListItem(item);
        return list;
    }
              
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getAllModulesAllIssueTypesList(ScarabUser user)
        throws TorqueException
    {
        MITList list = MITListManager.getInstance();
        list.setModifiable(false);
        list.setScarabUser(user);
        list.setName(Localization.getString(ScarabConstants.DEFAULT_BUNDLE_NAME,
                                      user.getLocale(),
                                      "AllModulesAndIssueTypes"));

        MITListItem item = MITListItemManager.getInstance();
        item.setModuleId(MITListItem.MULTIPLE_KEY);
        list.addMITListItem(item);
        item.setIssueTypeId(MITListItem.MULTIPLE_KEY);
        return list;
    }
              
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getAllModulesSingleIssueTypeList(IssueType issueType,
                                                           ScarabUser user)
        throws TorqueException
    {
        MITList list = MITListManager.getInstance();
        list.setModifiable(false);
        list.setScarabUser(user);
        list.setName(Localization.format(ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         user.getLocale(),
                                         "CurrentIssueTypeAllModules", 
                                         issueType.getName()));

        MITListItem item = MITListItemManager.getInstance();
        item.setModuleId(MITListItem.MULTIPLE_KEY);
        item.setIssueType(issueType);
        list.addMITListItem(item);
        return list;
    }
              
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getInstanceFromIssueList(List issues, 
                                                   ScarabUser user)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        
        if (user == null) 
        {
            throw new IllegalArgumentException("Null user is not allowed."); //EXCEPTION
        }
        
        MITList list = getInstance();
        list.setScarabUser(user);
        List dupeCheck = list.getMITListItems();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            MITListItem item = MITListItemManager.getInstance();
            item.setModule(issue.getModule());
            item.setIssueType(issue.getIssueType());
            if (!dupeCheck.contains(item)) 
            {
                list.addMITListItem(item);
            }
        }
        
        return list;
    }
              
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getInstanceByName(String name, ScarabUser user)
        throws TorqueException
    {
        MITList result = null;
        Criteria crit = new Criteria();
        crit.add(MITListPeer.NAME, name);
        crit.add(MITListPeer.ACTIVE, true);
        crit.add(MITListPeer.USER_ID, user.getUserId());
        List mitLists = MITListPeer.doSelect(crit);
        if (mitLists != null && !mitLists.isEmpty()) 
        {
            result = (MITList)mitLists.get(0);
            // it is not good if more than one active list has the 
            // same name (per user).  We could throw an exception here
            // but its possible the system can still function under
            // this circumstance, so just log it for now.
            Log.get().error("Multiple active lists exist with list name="
                            + name + " for user=" + user.getUserName() + 
                            "("+user.getUserId()+")");
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/IssueManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        // saving an issue object could affect some cached results, since it could be a move
        Serializable obj = (Serializable)om;
        getMethodResult().removeAll(obj, Issue.GET_MODULE_ATTRVALUES_MAP);
        getMethodResult().remove(obj, Issue.GET_USER_ATTRIBUTEVALUES);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/AttributeGroupManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttributeGroupPeer.MODULE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/ActivitySetPeer.java
public static ActivitySet retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        ActivitySet result = null;
        Object obj = ScarabCache.get(TRANSACTION_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseActivitySetPeer.retrieveByPK(pk);
            ScarabCache.put(result, TRANSACTION_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (ActivitySet)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user, AttributeOption attributeOption)
        throws TorqueException, ScarabException, DataSetException
    {
        Criteria crit = new Criteria();

        Integer attributeId = attributeOption.getAttributeId();
        Integer optionId    = attributeOption.getOptionId();

        crit.add(AttributeValuePeer.ATTRIBUTE_ID, attributeId);
        crit.add(AttributeValuePeer.OPTION_ID,optionId);
        crit.add(AttributeValuePeer.DELETED,0);
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.TYPE_ID,this.getIssueTypeId());
        crit.add(IssuePeer.MOVED, 0);
        crit.add(IssuePeer.DELETED, 0);
        crit.addJoin(AttributeValuePeer.ISSUE_ID, IssuePeer.ISSUE_ID);

        int count = AttributeValuePeer.count(crit);
        return count;
    }
              
// in java/org/tigris/scarab/om/MITListItem.java
public String getAttributeDisplayName(final Attribute attribute) throws TorqueException
    {
        if (!isSingleIssueType())
        {
            // FIXME: we should in fact use isSingleModuleIssueType() here
            //        but the reference of multiple modules 
            //        is represented by moduleId == MULTIPE_KEY,
            //        which has the value of 0
            //        which is also the id of the global module
            //        probably null is a better value for MULTIPE_KEY
            throw new IllegalStateException(
               "method should not be called on an item " +
               "including issue types");
        }
        Module module = getModule();
        IssueType issueType = getIssueType();
        RModuleAttribute rma = module.getRModuleAttribute(attribute, issueType);
        String displayValue;
        
        // FIXME: When would the rma be null ? I got this error today, while performing a cross module
        //        query. But i couldn't find the cause.
        //        It may be related to an inconsistent submodule definition ...
        //        In order to debug this behaviour, i added a generic displayValue here. Now the NPE
        //        is away, but the generic displayValues don't appear either on the GUI. So whatever happens
        //        here, the associated items seem to be irrelevant on the GUI... To be further examined!
        if(rma != null)
        {
        	displayValue = rma.getDisplayValue();
        }
        else
        {
        	displayValue = "" + attribute.getName() + ":" + issueType.getName();
        }
        return displayValue;
    }
              
// in java/org/tigris/scarab/om/NotificationRule.java
public static NotificationRule createDefaultRule(Integer moduleId,
                                            Integer userId,
                                            Integer managerId,
                                            String activityType) throws TorqueException
    {
        NotificationRule rule = new NotificationRule();
        rule.setModuleId(moduleId);
        rule.setUserId(userId);
        rule.setActivityType(activityType);
        rule.setManagerId(managerId);

        // default settings.
        // currently hard coded. will later be
        // replaced by a default customization

        rule.setFilterState(true);   // enabled by default
        rule.setSendSelf(false);     // don't send to myself by default
        rule.setSendFailures(false); // don't notify me about failures by default
        rule.save();
        return rule;
    }
              
// in java/org/tigris/scarab/om/AttributeTypeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(AttributeTypePeer.ATTRIBUTE_TYPE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static boolean isNotificationEnabledFor(ScarabUser user, Issue issue, boolean isSelf, String activityType, ActivitySet activitySet) throws ScarabException, TorqueException
    {
        Integer userId   = user.getUserId();
        Module module    = issue.getModule();
        Integer moduleId = module.getModuleId();
        
        NotificationRule rule = getNotificationRule(moduleId, userId, activityType);
        boolean isEnabled;
        if(isSelf)
        {
            isEnabled = rule.getSendSelf();
        }
        else
        {
            if(issue.isSealed() && !activitySet.hasTransitionSealed())
            {
                isEnabled = false; // Do not send notifications to other users when Issue is "closed"
            }
            else
            {
                isEnabled = rule.getFilterState();
            }
        }
        
        if(isEnabled)
        {
            Notification notification = new Notification(user, issue);
            isEnabled = notification.sendConditionsMatch();
        }
        return isEnabled;
    }
              
// in java/org/tigris/scarab/om/RIssueTypeOption.java
public void delete(final ScarabUser user, final Module module)
         throws TorqueException, ScarabException
    {                
        if (user.hasPermission(ScarabSecurity.DOMAIN__EDIT, module))
        {
            final List rios = getIssueType().getRIssueTypeOptions(
                                      getAttributeOption().getAttribute(), false);
            final Criteria c = new Criteria()
                .add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
            RIssueTypeOptionPeer.doDelete(c);
            rios.remove(this);
            if (rios.size() > 0)
            {
                // Correct the ordering of the remaining options
                final ArrayList optIds = new ArrayList();
                for (int i=0; i<rios.size();i++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)rios.get(i);
                    optIds.add(rio.getOptionId());
                }
                final Criteria c2 = new Criteria()
                    .addIn(RIssueTypeOptionPeer.OPTION_ID, optIds)
                    .add(RIssueTypeOptionPeer.PREFERRED_ORDER, getOrder(), 
                         Criteria.GREATER_THAN);
                final List adjustRios = RIssueTypeOptionPeer.doSelect(c2);
                for (int j=0; j<adjustRios.size();j++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)adjustRios.get(j);
                    rio.setOrder(rio.getOrder() -1);
                    rio.save();
                }
            }
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/RIssueTypeOption.java
public RIssueTypeOption copyRio()
         throws TorqueException
    {                
        RIssueTypeOption rio = new RIssueTypeOption();
        rio.setIssueTypeId(getIssueTypeId());
        rio.setOptionId(getOptionId());
        rio.setActive(getActive());
        rio.setOrder(getOrder());
        rio.setWeight(getWeight());
        return rio;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public Issue getNewIssue(IssueType issueType)
        throws TorqueException
    {
        Issue issue = Issue.getNewInstance(this, issueType);
        issue.setDeleted(false);
        return issue;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public synchronized List getAncestors()
        throws TorqueException
    {
        if (parentModules == null)
        {
            parentModules = new ArrayList();
            Module parent = getParent();
             if (parent != null && !parent.getModuleId().equals(ROOT_ID) && !isEndlessLoop(parent))
            {
                addAncestors(parent);
            }
        }
        return parentModules;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
private void addAncestors(Module module)
        throws TorqueException
    {
        if (!module.getParentId().equals(ROOT_ID))
        {
            addAncestors(module.getParent());
        }
        parentModules.add(module);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean isEndlessLoop(Module parent)
        throws TorqueException
    {
        if (parent.getModuleId() != ROOT_ID)
        {
            Module parentParent = parent.getParent();
            if (parentParent != null && parentParent == this)
            {
                return true;
            }
        }
        return false;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public AttributeGroup createNewGroup (IssueType issueType)
        throws TorqueException
    {
        return issueType.createNewGroup(this);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getDedupeGroupsWithAttributes(IssueType issueType)
        throws TorqueException
    {
        List result = null;
        if(issueType == null)
        {
            result = new Vector(0);
        }
        else
        {
            Object obj = getMethodResult().get(this,
                    GET_DEDUPE_GROUPS_WITH_ATTRIBUTES, issueType);
            if (obj == null)
            {
                List attributeGroups = issueType.getAttributeGroups(this, true);
                result = new ArrayList(attributeGroups.size());
                for (Iterator itr = attributeGroups.iterator(); itr.hasNext();)
                {
                    AttributeGroup ag = (AttributeGroup) itr.next();
                    if (ag.getDedupe() && !ag.getAttributes().isEmpty())
                    {
                        result.add(ag);
                    }
                }
                getMethodResult().put(result, this,
                        GET_DEDUPE_GROUPS_WITH_ATTRIBUTES, issueType);
            }
            else
            {
                result = (List) obj;
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getDedupeAttributeGroups(IssueType issueType)
        throws TorqueException
    {
        return getDedupeAttributeGroups(issueType, true);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getDedupeAttributeGroups(IssueType issueType,
                                         boolean activeOnly)
        throws TorqueException
    {
        List groups = issueType.getAttributeGroups(this, activeOnly);
        List dedupeGroups = new ArrayList();
        for (int i =0;i< groups.size(); i++)
        {
            AttributeGroup group = (AttributeGroup)groups.get(i);
            if (group.getDedupe())
            {
                dedupeGroups.add(group);
            }
        }
        return dedupeGroups;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public int getDedupeSequence(IssueType issueType)
        throws TorqueException
    {
        return issueType.getDedupeSequence(this);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public ScarabUser[] getEligibleIssueReporters()
        throws TorqueException
    {
        return getUsers(ScarabSecurity.ISSUE__ENTER);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public ScarabUser[] getEligibleUsers(Attribute attribute)
        throws TorqueException,ScarabException
    {
        ScarabUser[] users = null;
        if (attribute.isUserAttribute()) 
        {
            String permission = attribute.getPermission();
            if (permission == null) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionNoAttributePermission,
                        attribute.getName());
            }
            else 
            {
                users = getUsers(permission);
            }
        }
        return users;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getSavedReports(final ScarabUser user)
        throws TorqueException,ScarabException
    {
        List reports = null;
        final Object obj = ScarabCache.get(this, GET_SAVED_REPORTS, user); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria()
                .add(ReportPeer.DELETED, 0);
            final Criteria.Criterion cc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.MODULE__PK, Criteria.EQUAL);
            cc.and(crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL));
            final Criteria.Criterion personalcc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.PERSONAL__PK, Criteria.EQUAL);
            personalcc.and(crit.getNewCriterion(
                ReportPeer.USER_ID, user.getUserId(), Criteria.EQUAL));
            final Criteria.Criterion personalmodulecc = crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL);
            personalmodulecc.or(crit.getNewCriterion(
                ReportPeer.MODULE_ID, null, Criteria.EQUAL));
            personalcc.and(personalmodulecc);
            cc.or(personalcc);
            crit.add(cc);
            crit.addAscendingOrderByColumn(ReportPeer.SCOPE_ID);
            final List torqueReports = ReportPeer.doSelect(crit);      
            // create ReportBridge's from torque Reports.
            if (!torqueReports.isEmpty()) 
            {
                reports = new ArrayList(torqueReports.size());
                for (Iterator i = torqueReports.iterator(); i.hasNext();) 
                {
                    final Report torqueReport = (Report)i.next();
                    try 
                    {
                        reports.add( new ReportBridge(torqueReport) );
                    }
                    catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }     
                    catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
                }
            }
            else 
            {
                reports = Collections.EMPTY_LIST;
            }

            ScarabCache.put(reports, this, GET_SAVED_REPORTS, user);
        }
        else 
        {
            reports = (List)obj;
        }
        return reports;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAttributes(final IssueType issueType)
        throws TorqueException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
        return getAttributes(crit);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAttributes(final Criteria criteria)
        throws TorqueException
    {
        final List moduleAttributes = getRModuleAttributes(criteria);
        final List attributes = new ArrayList(moduleAttributes.size());
        for (int i=0; i<moduleAttributes.size(); i++)
        {
            attributes.add(
               ((RModuleAttribute) moduleAttributes.get(i)).getAttribute());
        }
        return attributes;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUserAttributes(IssueType issueType)
        throws TorqueException
    {
        return getUserAttributes(issueType, true);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUserAttributes(IssueType issueType, boolean activeOnly)
        throws TorqueException
    {
        List rModuleAttributes = getRModuleAttributes(issueType, activeOnly, USER);
        List userAttributes = new ArrayList();

        for (int i=0; i<rModuleAttributes.size(); i++)
        {
            Attribute att = ((RModuleAttribute)rModuleAttributes.get(i)).getAttribute();
            userAttributes.add(att);
        }
        return userAttributes;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUserPermissions(IssueType issueType)
        throws TorqueException
    {
        List userAttrs = getUserAttributes(issueType, true);
        List permissions = new ArrayList();
        for (int i = 0; i < userAttrs.size(); i++)
        {
            String permission = ((Attribute)userAttrs.get(i)).getPermission();
            if (!permissions.contains(permission))
            {
                permissions.add(permission);
            }
        }
        return permissions;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public int getLastAttribute(IssueType issueType, String attributeType)
        throws TorqueException
    {
        List moduleAttributes = getRModuleAttributes(issueType, false, attributeType);
        int last = 0;

        for (int i=0; i<moduleAttributes.size(); i++)
        {
               int order = ((RModuleAttribute) moduleAttributes.get(i))
                         .getOrder();
               if (order > last)
               {
                   last = order;
               }
        }
        return last;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public int getLastAttributeOption(Attribute attribute, 
                                      IssueType issueType)
        throws TorqueException
    {
      List moduleOptions = getRModuleOptions(attribute, issueType);
      int last = 0;
      for (int i=0; i<moduleOptions.size(); i++)
        {
          int order = ((RModuleOption) moduleOptions.get(i))
            .getOrder();
          if (order > last)
            {
              last = order;
            }
        }
      return last;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void shiftAttributeOption(Attribute attribute, 
                                    IssueType issueType,
                                    int offset)
        throws TorqueException
    {
      List moduleOptions = getRModuleOptions(attribute, issueType, false);
      RModuleOption rmo;
      for (int i=0; i<moduleOptions.size(); i++)
        {
          rmo = (RModuleOption) moduleOptions.get(i);
          int order = rmo.getOrder();
          if (order >= offset && !rmo.getActive())
            {
              rmo.setOrder(order+1);
              rmo.save();
            }
        }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAvailableAttributes(IssueType issueType, 
                                       String attributeType)
        throws TorqueException
    {
        List allAttributes = AttributePeer.getAttributes(attributeType);
        List availAttributes = new ArrayList();
        List rModuleAttributes = getRModuleAttributes(issueType, false,
                                                      attributeType);
        List moduleAttributes = new ArrayList();
        if (rModuleAttributes.isEmpty())
        {
             availAttributes = allAttributes;
        }
        else
        {
            for (int i=0; i<rModuleAttributes.size(); i++)
            {
                moduleAttributes.add(
                   ((RModuleAttribute) rModuleAttributes.get(i)).getAttribute());
            }


            for (int i=0; i<allAttributes.size(); i++)
            {
                Attribute att = (Attribute)allAttributes.get(i);
                if (!moduleAttributes.contains(att))
                {
                    availAttributes.add(att);
                }
            }
         }
        return availAttributes;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAvailableAttributeOptions(Attribute attribute,
                                             IssueType issueType)
        throws TorqueException
    {
        List rModuleOptions = getRModuleOptions(attribute, issueType, false);
        List moduleOptions = new ArrayList();
        if (rModuleOptions != null)
        {
            for (int i=0; i<rModuleOptions.size(); i++)
            {
                moduleOptions.add(
                   ((RModuleOption) rModuleOptions.get(i)).getAttributeOption());
            }
        }

        List allOptions = attribute.getAttributeOptions(true);
        List availOptions = new ArrayList();

        for (int i=0; i<allOptions.size(); i++)
        {
            AttributeOption option = (AttributeOption)allOptions.get(i);
            if (!moduleOptions.contains(option) && !option.getDeleted())
            {
                availOptions.add(option);
            }
        }
        return availOptions;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getDefaultRModuleUserAttributes(IssueType issueType)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_DEFAULT_RMODULE_USERATTRIBUTES, 
                                     issueType); 
        if (obj == null) 
        {        
            result = new LinkedList();
            Attribute[] attributes = new Attribute[3];
            int count = 0;
            //attributes[count++] = issueType.getDefaultTextAttribute(this);
            //if (attributes[0] == null) 
            //{
            //    count = 0;
            //}            
            List rma1s = getRModuleAttributes(issueType, true, NON_USER);
            Iterator i = rma1s.iterator();

            // Find first default text attribute ...
            while (i.hasNext())
            {
                RModuleAttribute rmat = (RModuleAttribute)i.next();
                Attribute a = rmat.getAttribute();
                if (a.isTextAttribute() && rmat.getIsDefaultText()) 
                {
                    attributes[count++] = a;
                    break;
                }
            }

            // Add all UserAttributes
            List rma2s = getRModuleAttributes(issueType, true, USER);
            i = rma2s.iterator();
            while (i.hasNext() && count < 3)            
            {
                Attribute a = ((RModuleAttribute)i.next()).getAttribute();
                attributes[count++] = a;
            }

            // if we still have less than 3 attributes, give the non user
            // attributes another try
            i = rma1s.iterator();
            while (i.hasNext() && count < 3)            
            {
                Attribute a = ((RModuleAttribute)i.next()).getAttribute();
                if (!a.equals(attributes[0]) && !a.equals(attributes[1])) 
                {
                    attributes[count++] = a;
                }                
            }

            for (int j=0; j<attributes.length; j++) 
            {
                if (attributes[j] != null) 
                {
                    RModuleUserAttribute rmua = 
                        RModuleUserAttributeManager.getInstance();
                    rmua.setAttribute(attributes[j]);
                    rmua.setIssueType(issueType);
                    rmua.setOrder(j+1);
                    result.add(rmua);
                }
            }
            ScarabCache.put(result, this, GET_DEFAULT_RMODULE_USERATTRIBUTES, 
                            issueType);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public Issue getIssueById(String id)
        throws TorqueException
    {
        return IssueManager.getIssueById(id, getCode());
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getIssueTypes()
        throws TorqueException
    {
        return getIssueTypes(true); 
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getIssueTypes(boolean activeOnly)
        throws TorqueException
    {
        List types = null;
        Boolean activeOnlyValue = activeOnly ? Boolean.TRUE : Boolean.FALSE;
        Object obj = ScarabCache.get(this, GET_ISSUE_TYPES, activeOnlyValue);
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer. ISSUE_TYPE_ID);
            crit.add(RModuleIssueTypePeer.MODULE_ID, getModuleId());
            if (activeOnly)
            {
                crit.add(RModuleIssueTypePeer.ACTIVE, true);
            }
            crit.add(IssueTypePeer.PARENT_ID, 0);
            crit.add(IssueTypePeer.DELETED, 0);
            crit.addAscendingOrderByColumn(RModuleIssueTypePeer.PREFERRED_ORDER);             
            types = IssueTypePeer.doSelect(crit);
            ScarabCache.put(types, this, "getIssueTypes", activeOnlyValue);
        }
        else 
        {
            types = (List)obj;
        }
        return types;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getNavIssueTypes()
        throws TorqueException
    {
        List types = null;
        Object obj = getMethodResult().get(this, GET_NAV_ISSUE_TYPES); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer. ISSUE_TYPE_ID);
            crit.add(RModuleIssueTypePeer. MODULE_ID, getModuleId());
            crit.add(RModuleIssueTypePeer.ACTIVE, true);
            crit.add(RModuleIssueTypePeer.DISPLAY, true);
            crit.add(IssueTypePeer.PARENT_ID, 0);
            crit.add(IssueTypePeer.DELETED, 0);
            crit.addAscendingOrderByColumn(
                RModuleIssueTypePeer.PREFERRED_ORDER);
            types = IssueTypePeer.doSelect(crit);
            getMethodResult().put(types, this, GET_NAV_ISSUE_TYPES);
        }
        else 
        {
            types = (List)obj;
        }
        return types;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAvailableIssueTypes()
        throws TorqueException
    {
        List availIssueTypes = null;
        Object obj = ScarabCache.get(this, GET_AVAILABLE_ISSUE_TYPES); 
        if (obj == null) 
        {
            availIssueTypes = new ArrayList();
            List allIssueTypes = IssueTypePeer.getAllIssueTypes(false);
            List currentIssueTypes = getIssueTypes(false);
            Iterator iter = allIssueTypes.iterator();
            while (iter.hasNext())
            {
                IssueType issueType = (IssueType)iter.next();
                if (IssueTypePeer.getRootKey().equals(issueType.getParentId())
                    && !IssueTypePeer.getRootKey().equals(issueType.getIssueTypeId())
                    && !currentIssueTypes.contains(issueType))
                {
                    availIssueTypes.add(issueType);
                }
            }
            ScarabCache.put(availIssueTypes, this, GET_AVAILABLE_ISSUE_TYPES);
        }
        else 
        {
            availIssueTypes = (List)obj;
        }
        return availIssueTypes;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleAttributes(Criteria crit)
        throws TorqueException
    {
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.addJoin(RModuleAttributePeer.ATTRIBUTE_ID, 
                     AttributePeer.ATTRIBUTE_ID);
        crit.add(AttributePeer.DELETED, false);
        return RModuleAttributePeer.doSelect(crit);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleAttribute addRModuleAttribute(final IssueType issueType,
                                                final Attribute attribute)
        throws TorqueException, ScarabException
    {
        String attributeType = null;
        attributeType = (attribute.isUserAttribute() ? USER : NON_USER);

        final RModuleAttribute rma = new RModuleAttribute();
        rma.setModuleId(getModuleId());
        rma.setIssueTypeId(issueType.getIssueTypeId());
        rma.setAttributeId(attribute.getAttributeId());
        rma.setOrder(getLastAttribute(issueType, attributeType) + 1);
        rma.setConditionsArray(attribute.getConditionsArray(), attribute.getConditionOperator());
        rma.save();
        getRModuleAttributes(issueType, false, attributeType).add(rma);

        // Add to template type
        final IssueType templateType = IssueTypeManager
            .getInstance(issueType.getTemplateId(), false);
        final RModuleAttribute rma2 = new RModuleAttribute();
        rma2.setModuleId(getModuleId());
        rma2.setIssueTypeId(templateType.getIssueTypeId());
        rma2.setAttributeId(attribute.getAttributeId());
        rma2.setOrder(getLastAttribute(templateType, attributeType) + 1);
        rma2.save();
        return rma;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleOption addRModuleOption(IssueType issueType, 
                                          AttributeOption option)
        throws TorqueException
    {
        RModuleOption rmo = new RModuleOption();
        rmo.setModuleId(getModuleId());
        rmo.setIssueTypeId(issueType.getIssueTypeId());
        rmo.setOptionId(option.getOptionId());
        rmo.setDisplayValue(option.getName());
        rmo.setOrder(getLastAttributeOption(option.getAttribute(), issueType) + 1);
        return rmo;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleAttribute getRModuleAttribute(Attribute attribute,
			IssueType issueType) throws TorqueException {
		RModuleAttribute rma = null;
		if (attribute != null && issueType != null) {
			List rmas = null;
			if (attribute.isUserAttribute()) {
				rmas = getRModuleAttributes(issueType, false, USER);
			} else {
				rmas = getRModuleAttributes(issueType, false, NON_USER);
			}
			Iterator i = rmas.iterator();
			while (i.hasNext()) {
				rma = (RModuleAttribute) i.next();
				if (rma.getAttribute().equals(attribute)) {
					break;
				} else {
					rma = null;
				}
			}
		}
		return rma;
	}
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleAttributes(IssueType issueType)
        throws TorqueException
    {
        return getRModuleAttributes(issueType, false);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean hasAttributes(final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.addSelectColumn("count(" + RModuleAttributePeer.ATTRIBUTE_ID + ")");
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleAttributes(IssueType issueType, boolean activeOnly)
        throws TorqueException
    {
        return getRModuleAttributes(issueType, activeOnly, "all");
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleAttributes(IssueType issueType, boolean activeOnly,
                                     String attributeType)
        throws TorqueException
    {
        List rmas = null;
        Boolean activeBool = (activeOnly ? Boolean.TRUE : Boolean.FALSE);
        Object obj = getMethodResult().get(this, GET_R_MODULE_ATTRIBUTES,
            issueType,  activeBool, attributeType);
        if (obj == null)
        {
            Criteria crit = new Criteria();
            Integer issueTypeId = issueType.getIssueTypeId();
            Integer moduleId    = getModuleId();
            crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, issueTypeId);
            crit.add(RModuleAttributePeer.MODULE_ID, moduleId);
            crit.addAscendingOrderByColumn(RModuleAttributePeer.PREFERRED_ORDER);
            crit.addAscendingOrderByColumn(RModuleAttributePeer.DISPLAY_VALUE);
            
            if (activeOnly)
            {
                crit.add(RModuleAttributePeer.ACTIVE, true);
            }
            
            crit.addJoin(AttributePeer.ATTRIBUTE_ID, RModuleAttributePeer.ATTRIBUTE_ID); 
            if (USER.equals(attributeType))
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY);
            }
            else if (NON_USER.equals(attributeType))
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY,
                         Criteria.NOT_EQUAL);
            }
            
            rmas = RModuleAttributePeer.doSelect(crit); 
            getMethodResult().put(rmas, this, GET_R_MODULE_ATTRIBUTES, 
                issueType, activeBool, attributeType);
        }
        else
        {
            rmas = (List)obj;
        }
        return rmas;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAllAttributes()
        throws TorqueException
    {
    	Criteria crit = new Criteria();
    	crit.addJoin(RModuleAttributePeer.ATTRIBUTE_ID, AttributePeer.ATTRIBUTE_ID);
    	crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());  	 
    	crit.setDistinct();
    	List result = AttributePeer.doSelect(crit);
    	
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAllOptionAttributes()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.addJoin(RModuleAttributePeer.ATTRIBUTE_ID, AttributePeer.ATTRIBUTE_ID);
        crit.addIn(AttributePeer.ATTRIBUTE_TYPE_ID, OptionAttributeIds );
        crit.add(AttributePeer.DELETED, false);
        crit.add(RModuleAttributePeer.ACTIVE, true);
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.addAscendingOrderByColumn(
        		AttributePeer.ATTRIBUTE_NAME);
        crit.setDistinct();
        List result = AttributePeer.doSelect(crit);
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAllAttributeOptions(Integer attributeId)
            throws TorqueException, ScarabException
    {
        List result;
        if (attributeId == null)
        {
            this.getLog().warn(
                    "No attribute specified while fetching attribute options.");
            result = Collections.EMPTY_LIST;
        } else
        {
            int id = attributeId.intValue();
            Attribute attribute = Attribute.getInstance(id);
            if (attribute == null)
            {
                this.getLog().warn(
                        "No options found for Attribute [" + attributeId + "]");
                // L10NMessage msg = new
                // L10NMessage(L10NKeySet.AttributeNotInSession,""+attributeId);
                // throw new ScarabException(msg);
                result = Collections.EMPTY_LIST;
            } else
            {
                // Integer attributeId = attribute.getAttributeId();

                Criteria crit = new Criteria();
                crit.add(AttributeOptionPeer.ATTRIBUTE_ID, attributeId);
                crit.add(AttributeOptionPeer.DELETED, false);
                result = AttributeOptionPeer.doSelect(crit);
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getActiveAttributesByName(IssueType issueType,
                                          String attributeType)
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, 
                 issueType.getIssueTypeId());
        crit.addJoin(RModuleAttributePeer.ATTRIBUTE_ID, 
                     AttributePeer.ATTRIBUTE_ID);
        crit.add(AttributePeer.DELETED, false);
        crit.add(RModuleAttributePeer.ACTIVE, true);
        if (USER.equals(attributeType))
        {
            crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                     AttributeTypePeer.USER_TYPE_KEY);
            crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                     RModuleAttributePeer.ATTRIBUTE_ID); 
        }
        else if (NON_USER.equals(attributeType))
        {
            crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                     AttributeTypePeer.USER_TYPE_KEY,
                     Criteria.NOT_EQUAL);
        }
        crit.addAscendingOrderByColumn(
                RModuleAttributePeer.DISPLAY_VALUE);
        return AttributePeer.doSelect(crit);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleOptions(Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        return getRModuleOptions(attribute, issueType, true);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleOptions(Attribute attribute, IssueType issueType,
                                  boolean activeOnly)
        throws TorqueException
    {
        List allRModuleOptions    = getAllRModuleOptions(attribute, issueType);
        List resultRModuleOptions = null;

        if (allRModuleOptions != null) 
        {
            resultRModuleOptions = new ArrayList(allRModuleOptions.size());
            int orderIndex = 0;
            for (int i = 0; i < allRModuleOptions.size(); i++) 
            {
                RModuleOption rmo = (RModuleOption) allRModuleOptions.get(i);
                if (!activeOnly || rmo.getActive()) 
                {
                    rmo.setOrder(++orderIndex); // take care that the option order is consecutive
                    resultRModuleOptions.add(rmo);
                }
            }
        }

        return resultRModuleOptions;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
private List getAllRModuleOptions(Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        List rModOpts = EmptyList;

        if(attribute != null)
        {
            Object obj = getMethodResult().get(this, GET_ALL_R_MODULE_OPTIONS, attribute, issueType); 
            if (obj == null)
            {
                List options = attribute.getAttributeOptions(true);
                if (options != null && options.size() > 0)
                {
                    Integer[] optIds = new Integer[options.size()];
                    for (int i=optIds.length-1; i>=0; i--)
                    {
                        optIds[i] = ((AttributeOption)options.get(i)).getOptionId();
                    }
    
                    Criteria crit = new Criteria();
                    crit.add(RModuleOptionPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
                    crit.add(RModuleOptionPeer.MODULE_ID, getModuleId());
                    crit.addIn(RModuleOptionPeer.OPTION_ID, optIds);
                    crit.addAscendingOrderByColumn(RModuleOptionPeer.PREFERRED_ORDER);
                    crit.addAscendingOrderByColumn(RModuleOptionPeer.DISPLAY_VALUE);
                    rModOpts = getRModuleOptions(crit);
    
                    // It would be extremely suspicious to see a null value here.
                    assert (rModOpts != null); // for development 
                    if(rModOpts == null)       // for production
                    {
                        rModOpts = EmptyList;
                    }
                }
                getMethodResult().put(rModOpts, this, GET_ALL_R_MODULE_OPTIONS, attribute, issueType);
            }
            else 
            {
                rModOpts = (List)obj;
            }
        }
        return rModOpts;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleOption getRModuleOption(AttributeOption option, 
                                          IssueType issueType)
        throws TorqueException
    {
        RModuleOption rmo = null;
        List rmos = getRModuleOptions(option.getAttribute(),
                                      issueType, false);
        
        RModuleOption testRMO = null;
        for (Iterator i = rmos.iterator();i.hasNext();)
        {
            testRMO = (RModuleOption)i.next();
            if (testRMO.getAttributeOption().equals(option))
            {
                rmo = testRMO;
                break;
            }
        }
        return rmo;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAttributeOptions (Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        List attributeOptions = null;
        try
        {
            List rModuleOptions = getOptionTree(attribute, issueType, false);
            attributeOptions = new ArrayList(rModuleOptions.size());
            for (int i=0; i<rModuleOptions.size(); i++)
            {
                attributeOptions.add(
                    ((RModuleOption)rModuleOptions.get(i)).getAttributeOption());
            }
        }
        catch (Exception e)
        {
        }
        return attributeOptions;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getLeafRModuleOptions(Attribute attribute, IssueType issuetype)
        throws TorqueException
    {
        try
        {
            return getLeafRModuleOptions(attribute, issuetype, true);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getLeafRModuleOptions(Attribute attribute,
                                      IssueType issueType,
                                      boolean activeOnly)
        throws TorqueException
    {
        List rModOpts = null;        
        Boolean activeBool = (activeOnly ? Boolean.TRUE : Boolean.FALSE);
        Object obj = getMethodResult().get(this, GET_LEAF_R_MODULE_OPTIONS, 
                                           attribute, issueType, activeBool); 
        if (obj == null) 
        {        
            rModOpts = getRModuleOptions(attribute, issueType, activeOnly);
            if (rModOpts != null)
            {
                
                // put options in a map for searching
                Map optionsMap = new HashMap((int)(rModOpts.size()*1.5));
                for (int i=rModOpts.size()-1; i>=0; i--)
                {
                    RModuleOption rmo = (RModuleOption)rModOpts.get(i);
                    optionsMap.put(rmo.getOptionId(), null);
                }
                
                // remove options with descendants in the list
                for (int i=rModOpts.size()-1; i>=0; i--)
                {
                    AttributeOption option =
                        ((RModuleOption)rModOpts.get(i)).getAttributeOption();
                    List descendants = option.getChildren();
                    if (descendants != null)
                    {
                        for (int j=descendants.size()-1; j>=0; j--)
                        {
                            AttributeOption descendant =
                                (AttributeOption)descendants.get(j);
                            if (optionsMap
                                 .containsKey(descendant.getOptionId()))
                            {
                                rModOpts.remove(i);
                                break;
                            }
                        }
                    }
                }
                getMethodResult().put(rModOpts, this, GET_LEAF_R_MODULE_OPTIONS, 
                                      attribute, issueType, activeBool); 
            }
        }
        else 
        {
            rModOpts = (List)obj;
        }
        
        return rModOpts;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getOptionTree(Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        return getOptionTree(attribute, issueType, true);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getOptionTree(Attribute attribute, IssueType issueType,
                              boolean activeOnly)
        throws TorqueException
    {
        // I think this code should place an option that had multiple parents -
        // OSX and Mac,BSD is usual example - into the list in multiple places
        // and it should have the level set differently for the two locations.
        // The code is currently only placing the option in the list once.
        // Since the behavior is not well spec'ed, leaving as it is. - jdm

        List moduleOptions = null;
        moduleOptions = getRModuleOptions(attribute, issueType, activeOnly);
        if (moduleOptions == null)
        {
            return moduleOptions;
        }

        int size = moduleOptions.size();
        List[] ancestors = new List[size];

        // find all ancestors
        for (int i=size-1; i>=0; i--)
        {
            AttributeOption option =
                ((RModuleOption)moduleOptions.get(i)).getAttributeOption();
            ancestors[i] = option.getAncestors();
        }

        for (int i=0; i<size; i++)
        {
            RModuleOption moduleOption = (RModuleOption)moduleOptions.get(i);
            int level = 1;
            if (ancestors[i] != null)
            {
                // Set level for first ancestor as the option is only
                // shown once. 
                for (int j=ancestors[i].size()-1; j>=0; j--)
                {
                    AttributeOption ancestor =
                        (AttributeOption)ancestors[i].get(j);

                    for (int k=0; k<i; k++) 
                    {
                        RModuleOption potentialParent = (RModuleOption)
                            moduleOptions.get(k);
                        if (ancestor.getOptionId()
                            .equals(potentialParent.getOptionId()) &&
                            !ancestor.getOptionId()
                            .equals(moduleOption.getOptionId())   ) 
                        {
                            moduleOption.setLevel(level++);
                        }
                    }
                }
            }
        }

        return moduleOptions;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public String getOptionsTreeAsJSON(RunData data, String fromValue, Attribute attribute, Issue issue, boolean activeOnly) throws TorqueException 
    {    

        getLog().debug("Build options tree for Attribute [" + attribute.getName() + "]");
    	
    	List<RModuleOption> moduleOptions = (List<RModuleOption>) getRModuleOptions(attribute, issue.getIssueType(), activeOnly);
    		if (moduleOptions == null) {
    			return null;
    		}    	
    	    		
    		StringBuffer json = new StringBuffer("{ 'attributeId' : ");    		
    		json.append(attribute.getAttributeId());
    		json.append(", 'name' : '");
    		json.append(attribute.getName());
    		json.append("', '_children': [");
    		
			boolean first = true;
			
    		for (RModuleOption moduleOption : moduleOptions) {    			
        		if (!AbstractScarabModule.canMakeTransitionForOption(data, fromValue, moduleOption, issue, false)) continue;
    			if (moduleOption.getAttributeOption().getAncestors().size() == 1) {
    				if (!first) {
    					json.append(", ");
    				}
					json.append(this.getModuleOptionAsJSON(data, fromValue, attribute, issue, moduleOption));
    				first = false;
    			}
    		}
    		
    		json.append("]}");
    		
    		return json.toString();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
private String getModuleOptionAsJSON(RunData data, String fromValue, Attribute attribute, Issue issue, RModuleOption moduleOption) throws TorqueException {
    	StringBuffer json = new StringBuffer("{ 'optionId': ");
    	json.append(moduleOption.getOptionId());
    	json.append(", 'displayValue': '");
    	json.append(moduleOption.getDisplayValue());
    	json.append("', '_children': [");

		boolean first = true;

		moduleOption.getChildren(moduleOption.getIssueType());
		
    	for (RModuleOption rmo : (List<RModuleOption>) moduleOption.getChildren(moduleOption.getIssueType())) {
    		if (!AbstractScarabModule.canMakeTransitionForOption(data, fromValue, rmo, issue, false)) continue;
			if (!first) {
				json.append(", ");
			}
			json.append(this.getModuleOptionAsJSON(data, fromValue, attribute, issue, rmo));
			first = false;
    	}

    	json.append("]}");
    	
    	return json.toString();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleIssueTypes(String sortColumn, String sortPolarity)
        throws TorqueException
    {
        List types = null;
        Object obj = ScarabCache.get(this, GET_R_MODULE_ISSUE_TYPES); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.PARENT_ID, 0)
                .add(IssueTypePeer.DELETED, 0);
            if (sortColumn.equals("name"))
            {
                if (sortPolarity.equals("desc"))
                {
                    crit.addDescendingOrderByColumn(IssueTypePeer.NAME);
                }
                else
                {
                    crit.addAscendingOrderByColumn(IssueTypePeer.NAME);
                }
            }
            else
            {
                // sortColumn defaults to sequence #
                if (sortPolarity.equals("desc"))
                {
                    crit.addDescendingOrderByColumn(RModuleIssueTypePeer
                                                    .PREFERRED_ORDER);
                }
                else
                {
                    crit.addAscendingOrderByColumn(RModuleIssueTypePeer
                                                   .PREFERRED_ORDER);
                }
            }
            types = RModuleIssueTypePeer.doSelect(crit);
            ScarabCache.put(types, this, GET_R_MODULE_ISSUE_TYPES);
        }
        else 
        {
            types = (List) obj;
        }
        return types;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addAttributeOption(final IssueType issueType, 
            final AttributeOption option)
        throws TorqueException, ScarabException
    {
        final RModuleOption rmo = addRModuleOption(issueType, option);
        rmo.save();
        shiftAttributeOption(option.getAttribute(), issueType, rmo.getOrder());

        // add module-attributeoption mappings to template type
        final IssueType templateType = IssueTypeManager
                 .getInstance(issueType.getTemplateId());
        final RModuleOption rmo2 = addRModuleOption(templateType, option);
        rmo2.save();
        //FIXME: is it useful to shift options for the templateType?
        //shiftAttributeOption(option.getAttribute(), templateType, rmo.getOrder());
        
        //if the cache is not cleared, when two options are added at the same time, 
        //getLastAttributeOption does not take into account the newest active options.
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void setRmaBasedOnIssueType(final RIssueTypeAttribute ria)
        throws TorqueException, ScarabException
    {
        final RModuleAttribute rma = new RModuleAttribute(); 
        rma.setModuleId(getModuleId());
        rma.setIssueTypeId(ria.getIssueTypeId());
        rma.setAttributeId(ria.getAttributeId());
        rma.setActive(ria.getActive());
        rma.setRequired(ria.getRequired());
        rma.setOrder(ria.getOrder());
        rma.setQuickSearch(ria.getQuickSearch());
        rma.setDefaultTextFlag(ria.getDefaultTextFlag());
        rma.save();
        final RModuleAttribute rma2 = rma.copy();
        rma2.setModuleId(getModuleId());
        rma2.setIssueTypeId(ria.getIssueType().getTemplateId());
        rma2.setAttributeId(ria.getAttributeId());
        rma2.setActive(ria.getActive());
        rma2.setRequired(ria.getRequired());
        rma2.setOrder(ria.getOrder());
        rma2.setQuickSearch(ria.getQuickSearch());
        rma2.setDefaultTextFlag(ria.getDefaultTextFlag());
        rma2.save();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void setRmoBasedOnIssueType(final RIssueTypeOption rio)
        throws TorqueException, ScarabException
    {
        final RModuleOption rmo = new RModuleOption(); 
        rmo.setModuleId(getModuleId());
        rmo.setIssueTypeId(rio.getIssueTypeId());
        rmo.setOptionId(rio.getOptionId());
        rmo.setActive(rio.getActive());
        rmo.setOrder(rio.getOrder());
        rmo.setWeight(rio.getWeight());
        rmo.save();
        final RModuleOption rmo2 = rmo.copy();
        rmo2.setModuleId(getModuleId());
        rmo2.setIssueTypeId(rio.getIssueType().getTemplateId());
        rmo2.setOptionId(rio.getOptionId());
        rmo2.setActive(rio.getActive());
        rmo2.setOrder(rio.getOrder());
        rmo2.setWeight(rio.getWeight());
        rmo2.save();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean includesIssueType(final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleIssueTypePeer.MODULE_ID,
                 getModuleId());
        crit.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
                 issueType.getIssueTypeId());
        return RModuleIssueTypePeer.count(crit) > 0;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleIssueType getRModuleIssueType(final IssueType issueType)
        throws TorqueException
    {
        RModuleIssueType rmit = null;
        try
        {
            final SimpleKey[] keys = { SimpleKey.keyFor(getModuleId()), 
                                 SimpleKey.keyFor(issueType.getIssueTypeId())
            };
            rmit = RModuleIssueTypeManager.getInstance(new ComboKey(keys));
        }
        catch (NoRowsException e)
        {
            // ignore and return null, if the rmit does not exist
        }
        return rmit;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getTemplateTypes()
        throws TorqueException, ScarabException
    {
        List templateTypes = new ArrayList();
        final Object obj = ScarabCache.get(this, GET_TEMPLATE_TYPES); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                     IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.DELETED, 0);
            final List rmits = RModuleIssueTypePeer.doSelect(crit);
            for (int i=0; i<rmits.size(); i++)
            {
                final RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
                final IssueType templateType = rmit.getIssueType().getTemplateIssueType();
                templateTypes.add(templateType);
            }
            ScarabCache.put(templateTypes, this, GET_TEMPLATE_TYPES);
        }
        else 
        {
            templateTypes = (List)obj;
        }
        return templateTypes;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUnapprovedQueries() throws TorqueException
    {
        List queries = null;
        Object obj = ScarabCache.get(this, GET_UNAPPROVED_QUERIES); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(3);
            crit.add(QueryPeer.APPROVED, 0)
                .add(QueryPeer.DELETED, 0)
                .add(QueryPeer.MODULE_ID, getModuleId());
            queries = QueryPeer.doSelect(crit);
            ScarabCache.put(queries, this, GET_UNAPPROVED_QUERIES);
        }
        else 
        {
            queries = (List)obj;
        }
        return queries;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUnapprovedTemplates() throws TorqueException
    {
        List templates = null;
        Object obj = ScarabCache.get(this, GET_UNAPPROVED_TEMPLATES); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(3);
            crit.add(IssueTemplateInfoPeer.APPROVED, 0)
                .addJoin(IssuePeer.ISSUE_ID, IssueTemplateInfoPeer.ISSUE_ID)
                .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MOVED, 0)
                .add(IssuePeer.MODULE_ID, getModuleId());
            templates = IssuePeer.doSelect(crit);
            ScarabCache.put(templates, this, GET_UNAPPROVED_TEMPLATES);
        }
        else 
        {
            templates = (List)obj;
        }
        return templates;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void setInitialAttributesAndIssueTypes()
        throws TorqueException, DataSetException, ScarabException
    {
        isInitializing = true;
        ValidationException ve = null;
        try
        {
        // Add defaults for issue types and attributes 
        // from parent module
        final Module parentModule = ModuleManager.getInstance(getParentId());
        if(parentModule != null && parentModule.getModuleId().intValue() != 0){
        	inheritFromParent(parentModule);  //don't inherit anything from global data/module
        }
        
        final List defaultIssueTypes = IssueTypePeer.getDefaultIssueTypes();
        for (int i=0; i< defaultIssueTypes.size(); i++)
        {
            final IssueType defaultIssueType = (IssueType)defaultIssueTypes.get(i);
            if (!includesIssueType(defaultIssueType))
            {
                try
                {
                    addIssueType(defaultIssueType);
                }
                catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
            }
        }
        }
        finally
        {
            isInitializing = false;
        }
        if (ve != null) 
        {
            throw ve;
        }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void inheritFromParent(final Module parentModule)
        throws TorqueException, ScarabException
    {
        final Integer newModuleId = getModuleId();
        AttributeGroup ag1;
        AttributeGroup ag2;
        RModuleAttribute rma1 = null;
        RModuleAttribute rma2 = null;
            
        //save RModuleAttributes for template types.
        final List templateTypes = parentModule.getTemplateTypes();
        for (int i=0; i<templateTypes.size(); i++)
        {
            final IssueType it = (IssueType)templateTypes.get(i);
            final List rmas = parentModule.getRModuleAttributes(it);
            for (int j=0; j<rmas.size(); j++)
            {
                rma1 = (RModuleAttribute)rmas.get(j);
                rma2 = rma1.copy();
                rma2.setModuleId(newModuleId);
                rma2.setAttributeId(rma1.getAttributeId());
                rma2.setIssueTypeId(rma1.getIssueTypeId());
                getLog().debug("[ASM] Saving rma for new template type: " + 
                                    rma2.getModuleId()
                                    + "-" + rma2.getIssueTypeId() + "-" +
                                    rma2.getAttributeId());
                rma2.save();
            }
        }

        // set module-issue type mappings
        final List rmits = parentModule.getRModuleIssueTypes();
        for (int i=0; i<rmits.size(); i++)
        {
            final RModuleIssueType rmit1 = (RModuleIssueType)rmits.get(i);
            final RModuleIssueType rmit2 = rmit1.copy();
            rmit2.setModuleId(newModuleId);
            rmit2.save();
            final IssueType issueType = rmit1.getIssueType();

            // set attribute group defaults
            final List attributeGroups = issueType
                .getAttributeGroups(parentModule, true);
            for (int j=0; j<attributeGroups.size(); j++)
            {
                ag1 = (AttributeGroup)attributeGroups.get(j);
                ag2 = ag1.copy();
                ag2.setModuleId(newModuleId);
                ag2.getRAttributeAttributeGroups().clear();    // are saved later
                ag2.save();

                final List attributes = ag1.getAttributes();
                for (int k=0; k<attributes.size(); k++)
                {
                    final Attribute attribute = (Attribute)attributes.get(k);

                    // set attribute-attribute group defaults
                    final RAttributeAttributeGroup raag1 = ag1
                        .getRAttributeAttributeGroup(attribute);
                    final RAttributeAttributeGroup raag2 = raag1.copy();
                    raag2.setGroupId(ag2.getAttributeGroupId());
                    raag2.setAttributeId(raag1.getAttributeId());
                    raag2.setOrder(raag1.getOrder());
                    raag2.save();
                }
            }

            // set module-attribute defaults
            final List rmas = parentModule.getRModuleAttributes(issueType);
            if (rmas != null && rmas.size() >0)
            {
                for (int j=0; j<rmas.size(); j++)
                {
                    rma1 = (RModuleAttribute)rmas.get(j);
                    rma2 = rma1.copy();
                    rma2.setModuleId(newModuleId);
                    rma2.setAttributeId(rma1.getAttributeId());
                    rma2.setIssueTypeId(rma1.getIssueTypeId());
                    rma2.save();

                    // set module-option mappings
                    final Attribute attribute = rma1.getAttribute();
                    if (attribute.isOptionAttribute())
                    {
                        final List rmos = parentModule.getRModuleOptions(attribute,
                                                                   issueType);
                        if (rmos != null && rmos.size() > 0)
                        {
                            for (int m=0; m<rmos.size(); m++)
                            {
                                final RModuleOption rmo1 = (RModuleOption)rmos.get(m);
                                final RModuleOption rmo2 = rmo1.copy();
                                rmo2.setOptionId(rmo1.getOptionId());
                                rmo2.setModuleId(newModuleId);
                                rmo2.setIssueTypeId(issueType.getIssueTypeId());
                                rmo2.save();

                                // Save module-option mappings for template types
                                final RModuleOption rmo3 = rmo1.copy();
                                rmo3.setOptionId(rmo1.getOptionId());
                                rmo3.setModuleId(newModuleId);
                                rmo3.setIssueTypeId(issueType.getTemplateId());
                                rmo3.save();
                            }
                        }
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean isInitializing()
        throws TorqueException
    {
        return isInitializing;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public String getIssueRegexString()
        throws TorqueException
    {
        // regex =  /(issue|bug)\s+#?\d+/i
        List rmitsList = getRModuleIssueTypes();
        StringBuffer regex = new StringBuffer(30 + 10 * rmitsList.size());
        regex.append(REGEX_PREFIX);
        Iterator rmits = rmitsList.iterator();
        while (rmits.hasNext()) 
        {
            regex.append('|')
                .append(((RModuleIssueType)rmits.next()).getDisplayName());
        }
        regex.append(REGEX_SUFFIX);
        return regex.toString();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public REProgram getIssueRegex()
        throws TorqueException
    {
        String regex = getIssueRegexString();
        RECompiler rec = new RECompiler();
        REProgram rep = null;
        try
        {
            rep = rec.compile(regex);
        }
        catch (RESyntaxException e)
        {
            getLog().error("Could not compile regex: " + regex, e);
            try
            {
                rep = rec.compile(REGEX_PREFIX + REGEX_SUFFIX);
            }
            catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
        }
        // FIXME: we should cache the above result
        return rep;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public static Attribute getInstance(int id)
        throws TorqueException
    {
        return getInstance(new Integer(id));
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public static Attribute getInstance(Integer id)
        throws TorqueException
    {
        return AttributeManager.getInstance(id);
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public static Attribute getInstance(final String attributeName)
        throws TorqueException
    {
        Attribute result = null;
// TODO Should attributes even be cached by name?   What if the name is changed?
        Object obj = ScarabCache.get(ATTRIBUTE, GET_INSTANCE, attributeName.toLowerCase()); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add (AttributePeer.ATTRIBUTE_NAME, attributeName);
            crit.setIgnoreCase(true);
            final List attributes = AttributePeer.doSelect(crit);
            if (attributes.size() > 0)
            {
                result = (Attribute) attributes.get(0);
                ScarabCache.put(result, ATTRIBUTE, GET_INSTANCE, attributeName.toLowerCase());
            } 
        }
        else 
        {
            result = (Attribute)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public static boolean checkForDuplicate(String attributeName)
        throws TorqueException
    {
        return (getInstance(attributeName) != null);
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public static boolean checkForDuplicate(String attributeName,
                                            Attribute attribute)
        throws TorqueException
    {
        return (checkForDuplicate(attributeName) &&
                !attributeName.equals(attribute.getName()));
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public String getCreatedUserName() throws TorqueException
    {
        final Integer userId = getCreatedBy();
        String userName = null;
        if (userId == null || userId.intValue() == 0)
        {
            userName = DEFAULT.getMessage();
        }
        else
        {
            final ScarabUser su = ScarabUserManager
                .getInstance(SimpleKey.keyFor(userId));
            userName = su.getName();
        }
        return userName;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public static List getAllAttributeTypes()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(ATTRIBUTE, GET_ALL_ATTRIBUTE_TYPES); 
        if (obj == null) 
        {        
            result = AttributeTypePeer.doSelect(new Criteria());
            ScarabCache.put(result, ATTRIBUTE, GET_ALL_ATTRIBUTE_TYPES);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public List getCompatibleAttributeTypes()
        throws TorqueException, DataSetException
    {
        List result = null;
        final Object obj = ScarabCache.get(this, GET_COMPATIBLE_ATTRIBUTE_TYPES); 
        if (obj == null) 
        {
            boolean inUse = !isNew();
            if (inUse) 
            {
                // check to see if attribute really has been used
                final Criteria crit = new Criteria();
                crit.add(AttributeValuePeer.ATTRIBUTE_ID, getAttributeId());
                inUse = AttributeValuePeer.count(crit) > 0; 
            }
            if (inUse) 
            {
                if (isTextAttribute()) 
                {
                    final Criteria crit = new Criteria();
                    crit.addIn(AttributeTypePeer.ATTRIBUTE_TYPE_ID, AttributeTypePeer.TEXT_PKS);
                    result = AttributeTypePeer.doSelect(crit);                
                }
                else if (this.isOptionAttribute())
                {
                    final Criteria crit = new Criteria();
                    crit.addIn(AttributeTypePeer.ATTRIBUTE_TYPE_ID, AttributeTypePeer.OPTION_PKS);
                    result = AttributeTypePeer.doSelect(crit);                
                }
                else 
                {
                    result = Collections.EMPTY_LIST;
                }
            }
            else 
            {
                result = getAllAttributeTypes();
            }
            ScarabCache.put(result, this, GET_COMPATIBLE_ATTRIBUTE_TYPES);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public AttributeType getAttributeType()
        throws TorqueException
    {
        AttributeType result = null;
        Object obj = ScarabCache.get(this, GET_ATTRIBUTE_TYPE);
        if (obj == null) 
        {
            result = super.getAttributeType();
            ScarabCache.put(result, this, GET_ATTRIBUTE_TYPE);
        }
        else
        {
            result = (AttributeType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public static List getAllAttributes()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(ATTRIBUTE, GET_ALL_ATTRIBUTES); 
        if (obj == null) 
        {        
            result = AttributePeer.doSelect(new Criteria());
            ScarabCache.put(result, ATTRIBUTE, GET_ALL_ATTRIBUTES);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean isOptionAttribute()
        throws TorqueException
    {
        if (getTypeId() != null) 
        {
            return getAttributeType().getAttributeClass().getName()
                .equals(SELECT_ONE);
        }
        return false;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean isUserAttribute()
        throws TorqueException
    {
        if (getTypeId() != null) 
        {
            return getAttributeType().getAttributeClass().getName()
                .equals(USER_ATTRIBUTE);
        }
        return false;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean isTextAttribute()
        throws TorqueException
    {
        boolean isText = false;
        if (getTypeId() != null) 
        {
            for (int i=0; i<TEXT_TYPES.length && !isText; i++) 
            {
                isText = TEXT_TYPES[i].equals(getAttributeType().getName());
            }
        }
        return isText;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean isIntegerAttribute()
        throws TorqueException
    {
        return getTypeId() != null 
                && INTEGER_ATTRIBUTE.equals(getAttributeType().getName());
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean isDateAttribute()
        throws TorqueException
    {
        boolean isDate = false;
        if(getTypeId() != null)
        {
            isDate = "date".equals(getAttributeType().getName());            
        }
        return isDate;
     }
              
// in java/org/tigris/scarab/om/Attribute.java
public AttributeOption getAttributeOption(Integer pk)
        throws TorqueException
    {
        if (optionsMap == null)
        {
            buildOptionsMap();
        }
        return (AttributeOption)optionsMap.get(pk);
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public AttributeOption getAttributeOption(String optionID)
        throws TorqueException
    {
        if (optionID == null || optionID.length() == 0)
        {
            throw new TorqueException("optionId is empty"); //EXCEPTION
        }
        return getAttributeOption(new Integer(optionID));
    }
              
// in java/org/tigris/scarab/om/Attribute.java
private List getAllAttributeOptions()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_ALL_ATTRIBUTE_OPTIONS); 
        if (obj == null) 
        {
            Criteria crit = new Criteria();
            crit.addJoin(AttributeOptionPeer.OPTION_ID, 
                         ROptionOptionPeer.OPTION2_ID);
            crit.add(AttributeOptionPeer.ATTRIBUTE_ID, this.getAttributeId());
            crit.addAscendingOrderByColumn(ROptionOptionPeer.PREFERRED_ORDER);
            result = AttributeOptionPeer.doSelect(crit);
            ScarabCache.put(result, this, GET_ALL_ATTRIBUTE_OPTIONS);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public List getParentChildAttributeOptions()
        throws TorqueException
    {
        if (parentChildAttributeOptions == null)
        {
            List rooList = getOrderedROptionOptionList();
            List aoList = getOrderedAttributeOptionList();
            parentChildAttributeOptions = new ArrayList(rooList.size());
            for (int i=0; i<rooList.size();i++)
            {
                ROptionOption roo = (ROptionOption)rooList.get(i);
                AttributeOption ao = (AttributeOption)aoList.get(i);
    
                ParentChildAttributeOption pcao = ParentChildAttributeOption
                        .getInstance(roo.getOption1Id(), roo.getOption2Id());
                pcao.setParentId(roo.getOption1Id());
                pcao.setOptionId(roo.getOption2Id());
                pcao.setPreferredOrder(roo.getPreferredOrder());
                pcao.setWeight(roo.getWeight());
                pcao.setName(ao.getName());
                pcao.setDeleted(ao.getDeleted());
                pcao.setAttributeId(this.getAttributeId());
                pcao.setStyle(ao.getStyle());
                parentChildAttributeOptions.add(pcao);
            }
        }
        return parentChildAttributeOptions;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public List getOrderedROptionOptionList()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_ORDERED_ROPTIONOPTION_LIST); 
        if (obj == null) 
        {        
            if (orderedROptionOptionList == null)
            {
                Criteria crit = new Criteria();
                crit.addJoin(AttributeOptionPeer.OPTION_ID, 
                             ROptionOptionPeer.OPTION2_ID);
                crit.add(AttributeOptionPeer.ATTRIBUTE_ID, getAttributeId());
                crit.addAscendingOrderByColumn(
                    ROptionOptionPeer.PREFERRED_ORDER);
                orderedROptionOptionList = ROptionOptionPeer.doSelect(crit);
            }
            result = orderedROptionOptionList;
            ScarabCache.put(result, this, GET_ORDERED_ROPTIONOPTION_LIST);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public List getOrderedAttributeOptionList()
        throws TorqueException
    {
        if (orderedAttributeOptionList == null)
        {
            Criteria crit = new Criteria();
            crit.addJoin(AttributeOptionPeer.OPTION_ID, ROptionOptionPeer.OPTION2_ID);
            crit.add(AttributeOptionPeer.ATTRIBUTE_ID, this.getAttributeId());
            crit.addAscendingOrderByColumn(ROptionOptionPeer.PREFERRED_ORDER);
            orderedAttributeOptionList = AttributeOptionPeer.doSelect(crit);
        }
        return orderedAttributeOptionList;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public List getAttributeOptions(boolean includeDeleted)
        throws TorqueException
    {
        List allOptions = getAllAttributeOptions();
        List nonDeleted = new ArrayList(allOptions.size());
        if (includeDeleted) 
        {
            return allOptions;
        }
        else 
        {
            for (int i=0; i<allOptions.size(); i++) 
            {
                AttributeOption option = (AttributeOption)allOptions.get(i);
                if (!option.getDeleted())
                {
                    nonDeleted.add(option);
                }
            }
            return nonDeleted;
        }
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public synchronized void buildOptionsMap()
        throws TorqueException
    {
        if (getAttributeType().getAttributeClass().getName()
             .equals(SELECT_ONE))
        {
            // synchronized method due to getattributeOptionsWithDeleted, this needs
            // further investigation !FIXME!
            attributeOptionsWithDeleted = this.getAllAttributeOptions();
            optionsMap = new HashMap((int)(1.25*attributeOptionsWithDeleted.size()+1));
    
            attributeOptionsWithoutDeleted = new ArrayList(attributeOptionsWithDeleted.size());
            for (int i=0; i<attributeOptionsWithDeleted.size(); i++) 
            {
                AttributeOption option = (AttributeOption)attributeOptionsWithDeleted.get(i);
                optionsMap.put(option.getOptionId(), option);
                if (!option.getDeleted()) 
                {
                    attributeOptionsWithoutDeleted.add(attributeOptionsWithDeleted.get(i));
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public List getActivitys() throws TorqueException
    {
        return null;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public Attribute copyAttribute(ScarabUser user)
        throws TorqueException
    {
        Attribute newAttribute = new Attribute();
        newAttribute.setName(getName() + " (copy)");
        newAttribute.setDescription(getDescription());
        newAttribute.setStyle(getStyle());
        newAttribute.setFieldSize(getFieldSize());
        newAttribute.setFormat(getFormat());
        newAttribute.setHint(getHint());
        newAttribute.setTypeId(getTypeId());
        newAttribute.setPermission(getPermission());
        newAttribute.setRequiredOptionId(getRequiredOptionId());
        newAttribute.setConditionsArray(getConditionsArray(), getConditionOperator());
        newAttribute.setAction(getAction());
        newAttribute.setCreatedBy(user.getUserId());
        newAttribute.setCreatedDate(new Date());
        newAttribute.setDeleted(getDeleted());
        newAttribute.setMultiValue(getMultiValue());
        newAttribute.save();

        List attributeOptions = getAttributeOptions();
        for (int i=0;i<attributeOptions.size();i++)
        {
            AttributeOption option = (AttributeOption)attributeOptions.get(i);
            AttributeOption newOption = new AttributeOption();
            newOption.setOptionId(option.getOptionId());
            newOption.setAttributeId(newAttribute.getAttributeId());
            newOption.setName(option.getName());
            newOption.setDeleted(option.getDeleted());
            newOption.save();

            // Copy options's record in  R_OPTION_OPTION table
            List roos = option.getROptionOptionsRelatedByOption2Id();
            for (int j=0;j<roos.size();j++)
            {
                ROptionOption roo = (ROptionOption)roos.get(j);
                ROptionOption newRoo = new ROptionOption();
                newRoo.setOption2Id(newOption.getOptionId());
                newRoo.setOption1Id(roo.getOption1Id());
                newRoo.setRelationshipId(roo.getRelationshipId());
                newRoo.setWeight(roo.getWeight());
                newRoo.setPreferredOrder(roo.getPreferredOrder());
                newRoo.save();
             }
        }
        return newAttribute;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasModuleMappings()
        throws TorqueException, DataSetException
    {
        return hasMapping((Module) null, (IssueType) null);
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasMapping(final Module module, final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        if (module != null)
        {
            crit.add(RModuleAttributePeer.MODULE_ID,
                     module.getModuleId());
        }
        if (issueType != null)
        {
            crit.add(RModuleAttributePeer.ISSUE_TYPE_ID,
                     issueType.getIssueTypeId());
        }
        crit.addSelectColumn("count(" + RModuleAttributePeer.ATTRIBUTE_ID + ")");
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasGlobalIssueTypeMappings()
        throws TorqueException, DataSetException
    {
        return hasGlobalMapping((IssueType) null);
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasGlobalMapping(IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        if (issueType != null)
        {
            crit.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
                     issueType.getIssueTypeId());
        }
        crit.addSelectColumn("count(" + RIssueTypeAttributePeer.ATTRIBUTE_ID
                             + ')');
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public void deleteModuleMappings()
        throws TorqueException, ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID,
                 getAttributeId());
        crit.addJoin(RAttributeAttributeGroupPeer.GROUP_ID,
                     AttributeGroupPeer.ATTRIBUTE_GROUP_ID);
        crit.add(AttributeGroupPeer.MODULE_ID, (Object)null, Criteria.NOT_EQUAL);
        final List raags = RAttributeAttributeGroupPeer.doSelect(crit);
        for (Iterator i = raags.iterator(); i.hasNext();)
        {
            ((RAttributeAttributeGroup)i.next()).delete();
        }

        crit = new Criteria();
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID, 
                 getAttributeId());
        final List rmas = RModuleAttributePeer.doSelect(crit);
        for (int i=0; i<rmas.size(); i++)
        {
            final RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
            rma.delete(true);
        }
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public void deleteIssueTypeMappings()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID,
                 getAttributeId());
        crit.addJoin(RAttributeAttributeGroupPeer.GROUP_ID,
                     AttributeGroupPeer.ATTRIBUTE_GROUP_ID);
        crit.add(AttributeGroupPeer.MODULE_ID, null);
        List raags = RAttributeAttributeGroupPeer.doSelect(crit);
        for (Iterator i = raags.iterator(); i.hasNext();)
        {
            ((RAttributeAttributeGroup)i.next()).delete();
        }

        crit = new Criteria();
        crit.add(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        List rias = RIssueTypeAttributePeer.doSelect(crit);
        for (Iterator i = rias.iterator(); i.hasNext();)
        {
            ((RIssueTypeAttribute)i.next()).delete();
        }
        
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/Attribute.java
private List getAssociatedIssueTypes()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        crit.addJoin(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
                 IssueTypePeer.ISSUE_TYPE_ID);
        List issueTypeList = IssueTypePeer.doSelect(crit);
        return issueTypeList;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean isSystemDefined()
        throws TorqueException
    {
        boolean systemDefined = false;
        List issueTypeList = getAssociatedIssueTypes();
        for (Iterator i = issueTypeList.iterator(); i.hasNext();)
        {
            if (((IssueType)i.next()).isSystemDefined())
            {
                systemDefined = true;
                break;
            }
        }
        return systemDefined;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public List<Condition> getConditions() throws TorqueException
    {
        if (collConditions == null)
        {
            Criteria crit = new Criteria();
            crit.add(ConditionPeer.ATTRIBUTE_ID, this.getAttributeId());
            crit.add(ConditionPeer.MODULE_ID, null);
            crit.add(ConditionPeer.TRANSITION_ID, null);
            crit.add(ConditionPeer.ISSUE_TYPE_ID, null);
            collConditions = getConditions(crit);
        }
        return collConditions;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public void setConditionsArray(Integer aOptionId[], Integer operator) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.ATTRIBUTE_ID, this.getAttributeId());
        crit.add(ConditionPeer.OPERATOR, this.getConditionOperator());
        crit.add(ConditionPeer.MODULE_ID, null);
        crit.add(ConditionPeer.ISSUE_TYPE_ID, null);
        crit.add(ConditionPeer.TRANSITION_ID, null);
        ConditionPeer.doDelete(crit);
        this.save();
        this.getConditions().clear();
        ConditionManager.clear();
        if (aOptionId != null)
            for (int i=0; i<aOptionId.length; i++)
	        {
	            if (aOptionId[i].intValue() != 0)
	            {
		            Condition cond = new Condition();
		            cond.setAttributeId(this.getAttributeId());
		            cond.setOptionId(aOptionId[i]);
		            cond.setModuleId(null);
		            cond.setIssueTypeId(null);
		            cond.setTransitionId(null);
		            cond.setUserId(null);
		            cond.setOperator(operator);
		            this.addCondition(cond);
		            cond.save();
	            }
	        }
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public boolean isRequiredIf(Integer optionID) throws TorqueException
    {
        Condition cond = new Condition();
        cond.setAttributeId(this.getAttributeId());
        cond.setOptionId(optionID);
        cond.setModuleId(null);
        cond.setIssueTypeId(null);
        cond.setTransitionId(null);
        return this.getConditions().contains(cond);
    }
              
// in java/org/tigris/scarab/om/ReportManager.java
public List getNotDeletedModuleReports(Module module) 
        throws TorqueException
    {
        Criteria crit=new Criteria()
           .add(ReportPeer.DELETED,false)
           .add(ReportPeer.MODULE_ID,module.getModuleId())
           .add(ReportPeer.SCOPE_ID,Scope.MODULE__PK);

        List reports=ReportPeer.doSelect(crit);
        
        return reports;
    }
              
// in java/org/tigris/scarab/om/ReportManager.java
protected Persistent putInstanceImpl(Persistent om)
    throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(ReportPeer.REPORT_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/ActivitySetTypeManager.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException,ScarabException
    {
        ActivitySetType ttype = null; 
        Object obj = ScarabCache.get(TRANSACTION_TYPE, GET_INSTANCE, 
                                     activitySetTypeName);
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(ActivitySetTypePeer.NAME, activitySetTypeName);
            final List activitySetTypes = ActivitySetTypePeer.doSelect(crit);
            if (activitySetTypes.size() < 1) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetTypenameNotFound, 
                        activitySetTypeName);
            }
            if (activitySetTypes.size() > 1)
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetDuplicateTypename,
                        activitySetTypeName);
            }
            ttype = (ActivitySetType)activitySetTypes.get(0);
            ScarabCache.put(ttype, "ActivitySetType", "getInstance", 
                            activitySetTypeName);
        }
        else 
        {
            ttype = (ActivitySetType)obj;
        }
        
        return ttype;
    }
              
// in java/org/tigris/scarab/om/RModuleOptionManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(RModuleOptionPeer.MODULE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/RModuleOptionManager.java
public static final RModuleOption getInstance(Integer moduleId,  
        Integer issueTypeId, Integer optionId)
        throws TorqueException
    {
        SimpleKey[] keys = {
            new NumberKey(moduleId.toString()), 
            new NumberKey(issueTypeId.toString()), 
            new NumberKey(optionId.toString())
        };
        return getInstance(new ComboKey(keys));
    }
              
// in java/org/tigris/scarab/om/RModuleOptionManager.java
public static final RModuleOption getInstance(Module module, 
        IssueType issueType, AttributeOption option)
        throws TorqueException
    {
        SimpleKey[] keys = {
            SimpleKey.keyFor(module.getModuleId()),
            SimpleKey.keyFor(issueType.getIssueTypeId()),
            SimpleKey.keyFor(option.getOptionId())
        };
        return getInstance(new ComboKey(keys));
    }
              
// in java/org/tigris/scarab/om/TransitionPeer.java
public static void doDelete(Transition tran) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.TRANSITION_ID, tran.getTransitionId());
        ConditionPeer.doDelete(crit);
        BaseTransitionPeer.doDelete(tran);
    }
              
// in java/org/tigris/scarab/om/NotificationRulePeer.java
static public List<NotificationRule> getCustomization(Object moduleId, Object userId, Object activityType) throws TorqueException
        {
            List<NotificationRule> entries = null;
            Criteria crit = new Criteria();
            crit.add(MODULE_ID,       moduleId,     Criteria.EQUAL);
            crit.add(USER_ID,         userId,       Criteria.EQUAL);
            crit.add(ACTIVITY_TYPE,   activityType, Criteria.EQUAL);
            try {
                entries = (List<NotificationRule>)doSelect(crit);
            } catch (TorqueException e) {
                log.error("getPendingNotifications(): " + e);
            }
            /*
            if(entries.size()==0)
            {
                NotificationRule rule = 
                    NotificationRule.createDefaultRule(
                            (Integer)moduleId,
                            (Integer)userId,
                            NotificationManagerFactory.getInstance().getManagerId(),
                            ActivityType.getActivityType((String)activityType));
            }
            */
            return entries;
        }
              
// in java/org/tigris/scarab/om/NotificationRulePeer.java
static public Map<String,List<NotificationRule>> getCustomization(Object moduleId, Object userId) throws TorqueException
        {
            Map<String,List<NotificationRule>> entries = new Hashtable<String,List<NotificationRule>>();
            Set<String> codes = (Set<String>)ActivityType.getActivityTypeCodes();
            Iterator<String> iter = codes.iterator();
            while(iter.hasNext())
            {
                String code = (String)iter.next();
                List<NotificationRule> items = getCustomization(moduleId, userId, code);
                entries.put(code,items);
            }
            return entries;
        }
              
// in java/org/tigris/scarab/om/NotificationRulePeer.java
static public List<NotificationRule> getNotificationRules(ScarabUser user, Module module) throws TorqueException
        {
            List<NotificationRule> entries = new ArrayList<NotificationRule>();
            Set<String> codes = (Set<String>)ActivityType.getActivityTypeCodes();
            Iterator<String> iter = codes.iterator();
            Integer moduleId = module.getModuleId();
            Integer userId   = user.getUserId();
            while(iter.hasNext())
            {
                String code = (String)iter.next();
                List<NotificationRule> items = getCustomization(moduleId, userId, code);
                if(items != null && items.size()>0)
                entries.add(items.get(0));
            }
            return entries;
        }
              
// in java/org/tigris/scarab/om/NotificationRulePeer.java
public static void saveConditions(ScarabUser user, Module module, Integer[] aOptionId, Integer operator) throws TorqueException
        {
            deleteConditions(user, module);
            ConditionManager.clear();
            if (aOptionId != null)
                for (int i=0; i<aOptionId.length; i++)
                {
                    if (aOptionId[i].intValue() != 0)
                    {
                        Condition cond = new Condition();
                        cond.setAttributeId(null);
                        cond.setOptionId(aOptionId[i]);
                        cond.setModuleId(module.getModuleId());
                        cond.setIssueTypeId(null);
                        cond.setTransitionId(null);
                        cond.setUserId(user.getUserId());
                        cond.setOperator(operator);
                        cond.save();
                    }
                }
        }
              
// in java/org/tigris/scarab/om/NotificationRulePeer.java
public static List<Condition> getConditions(ScarabUser user, Module module) throws TorqueException
        {
            List<Condition> result = null;
            Criteria crit = new Criteria();
            crit.add(ConditionPeer.USER_ID, user.getUserId());
            crit.add(ConditionPeer.MODULE_ID, module.getModuleId());
            result = (List<Condition>)ConditionPeer.doSelect(crit);
            return result;
        }
              
// in java/org/tigris/scarab/om/NotificationRulePeer.java
public static Notification getEmptyNotificationFor(ScarabUser user, Module module) throws TorqueException
        {
            Notification notification = null;
            return notification;
            
        }
              
// in java/org/tigris/scarab/om/NotificationRulePeer.java
public static void deleteConditions(ScarabUser user, Module module) throws TorqueException
        {
            Criteria crit = new Criteria();
            crit.add(ConditionPeer.ATTRIBUTE_ID, null);
            crit.add(ConditionPeer.MODULE_ID, module.getModuleId());
            crit.add(ConditionPeer.ISSUE_TYPE_ID, null);
            crit.add(ConditionPeer.TRANSITION_ID, null);
            crit.add(ConditionPeer.USER_ID, user.getUserId());
            ConditionPeer.doDelete(crit);
        }
              
// in java/org/tigris/scarab/om/Issue.java
public static Issue getNewInstance(Module module, 
                                       IssueType issueType)
        throws TorqueException
    {
        Issue issue = new Issue(module, issueType);
        return issue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public String getUniqueId()
        throws TorqueException
    {
        if (getIdPrefix() == null)
        {
            setIdPrefix(getModule().getCode());
        }
        return getIdPrefix() + getIdCount();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public String getFederatedId()
        throws TorqueException
    {
        if (getIdDomain() != null) 
        {
            return getIdDomain() + '-' + getUniqueId();
        }
        return getUniqueId();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public static List parseIssueList(final Module module, final String theList)
        throws TorqueException, DataSetException
    {
        final String[] issues = StringUtils.split(theList, ",");
        final List results = new ArrayList();
        for (int i = 0; i < issues.length; i++)
        {
            if (issues[i].indexOf('*') != -1)
            {
                // Probably better to use more Torque here, but this
                // is definitely going to be faster and more
                // efficient.
                final String sql = "SELECT CONCAT(" + IssuePeer.ID_PREFIX + ',' +
                    IssuePeer.ID_COUNT + ") FROM " + IssuePeer.TABLE_NAME +
                    " WHERE " + IssuePeer.ID_PREFIX + " = '" +
                    module.getCode() + '\'';
                final List records = BasePeer.executeQuery(sql);
                for (Iterator j = records.iterator(); j.hasNext();)
                {
                    final Record rec = (Record)j.next();
                    results.add(rec.getValue(1).asString());
                }
            }
            // check for a -
            else if (issues[i].indexOf('-') == -1)
            {
                // Make sure user is not trying to access issues from another
                // module.
                final FederatedId fid = createFederatedId(module, issues[i]);
                if (!fid.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    final String[] args = { fid.getPrefix(), module.getCode() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixNotForModule", args)); //EXCEPTION
                }
                results.add(issues[i]);
            }
            else
            {
                final String[] issue = StringUtils.split(issues[i], "-");
                if (issue.length != 2)
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDRangeNotValid", issues[i])); //EXCEPTION
                }
                FederatedId fidStart = createFederatedId(module, issue[0]);
                FederatedId fidStop = createFederatedId(module, issue[1]);
                if (!fidStart.getPrefix().equalsIgnoreCase(module.getCode()) ||
                    !fidStop.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesNotForModule",
                                         module.getCode())); //EXCEPTION
                }
                else if (!fidStart.getPrefix()
                         .equalsIgnoreCase(fidStop.getPrefix()))
                {
                    final String[] args = { fidStart.getPrefix(),
                                      fidStop.getPrefix() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesDoNotMatch", args)); //EXCEPTION
                }
                else if (fidStart.getCount() > fidStop.getCount())
                {
                    FederatedId swap = fidStart;
                    fidStart = fidStop;
                    fidStop = swap;
                }

                for (int j = fidStart.getCount(); j <= fidStop.getCount();j++)
                {
                    results.add(fidStart.getPrefix() + j);
                }
            }
        }
        return results;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private static FederatedId createFederatedId(Module module, String id)
        throws TorqueException
    {
        FederatedId fid = null;
        try
        {
            fid = new FederatedId(id.trim());
            if (fid.getPrefix() == null || fid.getPrefix().length() == 0)
            {
                fid.setPrefix(module.getCode());
            }
        }
        catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
        return fid;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addUrl(final Attachment attachment, final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return addUrl(null, attachment, user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addUrl(ActivitySet activitySet, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        attachment.setTextFields(user, this, Attachment.URL__PK);
        attachment.save();

        activitySet = attachActivitySet(activitySet, user);

        // Save activity record
        ActivityManager
            .createTextActivity(this, activitySet, ActivityType.URL_ADDED, attachment);
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private Locale getLocale()
        throws TorqueException
    {
        return getModule().getLocale();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(final Attachment attachment, final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return addComment(null, attachment, user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(ActivitySet activitySet, 
                                  Attachment attachment, ScarabUser user)
        throws TorqueException, ScarabException
    {
        String comment = attachment.getData();
        if (comment == null || comment.length() == 0)
        {
            throw new ScarabException(L10NKeySet.NoDataInComment);
        }

        activitySet = attachActivitySet(activitySet, user);

        // populates the attachment with data to be a comment
        attachment = AttachmentManager
                        .getComment(attachment, this, user);

        ActivityManager
            .createTextActivity(this, activitySet,
                                ActivityType.COMMENT_ADDED, attachment);

        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.COMMENT_ADDED, activitySet, this, user);            

        index();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public synchronized void addFile(Attachment attachment, 
                                     ScarabUser user)
        throws TorqueException
    {
        attachment.setTypeId(Attachment.FILE__PK);
        attachment.setCreatedBy(user.getUserId());
        if (unSavedAttachments == null)
        {
            unSavedAttachments = new ArrayList();
        }
        unSavedAttachments.add(attachment);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public synchronized List getAttachments()
        throws TorqueException
    {
        if (unSavedAttachments != null && 
            unSavedAttachments.size() > 0)
        {
            return unSavedAttachments;
        }
        else
        {
            return super.getAttachments();
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public synchronized ActivitySet doSaveFileAttachments(final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return doSaveFileAttachments(null, user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public synchronized ActivitySet doSaveFileAttachments(ActivitySet activitySet,
                                                          final ScarabUser user)
        throws TorqueException, ScarabException
    {
        if (unSavedAttachments == null)
        {
            return activitySet;
        }
        activitySet = attachActivitySet(activitySet, user);

        final Iterator itr = unSavedAttachments.iterator();
        while (itr.hasNext())
        {
            final Attachment attachment = (Attachment)itr.next();
            // make sure we set the issue to the newly created issue
            attachment.setIssue(this);
            attachment.save();

            // Save activity record
            ActivityManager
                .createTextActivity(this, activitySet, ActivityType.ATTACHMENT_CREATED, attachment);

           
        }
        // reset the super method so that the query has to hit the database again
        // so that all of the information is cleaned up and reset.
        super.collAttachments = null;
        // we don't need this one anymore either.
        this.unSavedAttachments = null;
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void removeFile(String index)
        throws TorqueException
    {
        int indexInt = Integer.parseInt(index) - 1;
        if (indexInt >= 0)
        {
            if (unSavedAttachments != null && unSavedAttachments.size() > 0)
            {
                unSavedAttachments.remove(indexInt);
            }
            else
            {
                List attachList = getAttachments();
                if (attachList != null && attachList.size() > 0)
                {
                    attachList.remove(indexInt);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public RModuleIssueType getRModuleIssueType()
        throws TorqueException
    {
        RModuleIssueType rmit = null;
        Module module = getModule();
        IssueType issueType = getIssueType();
        if (module != null && issueType != null) 
        {
            rmit = module.getRModuleIssueType(issueType);
        }
        return rmit;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public LinkedMap getModuleAttributeValuesMap()
        throws TorqueException
    {
        return getModuleAttributeValuesMap(true);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public LinkedMap getModuleAttributeValuesMap(final boolean isActive)
        throws TorqueException
    {
    	LinkedMap result = null;
        Object obj = getCachedObject(GET_MODULE_ATTRVALUES_MAP, isActive ? Boolean.TRUE : Boolean.FALSE);
        if (obj == null) 
        {        
            List attributes = null;
            Module module = getModule();
            IssueType issueType = getIssueType();
            if (isActive)
            {
                attributes = issueType.getActiveAttributes(module);
            }
            else
            {
                attributes = module.getAttributes(issueType);
            }
            Map siaValuesMap = getAttributeValuesMap();
            result = new LinkedMap((int)(1.25*attributes.size() + 1));
            for (int i=0; i<attributes.size(); i++)
            {
                String key = ((Attribute)attributes.get(i)).getName().toUpperCase();
                if (siaValuesMap.containsKey(key))
                {
                    result.put(key, siaValuesMap.get(key));
                }
                else 
                {
                    Attribute attr      = (Attribute)attributes.get(i);
                    AttributeValue aval = AttributeValue.getNewInstance(attr, this);
                    addAttributeValue(aval);
                    result.put(key, aval);
                }
            }
            putCachedObject(result, GET_MODULE_ATTRVALUES_MAP, isActive ? Boolean.TRUE : Boolean.FALSE);
        }
        else
        {
            result = (LinkedMap)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public LinkedMap getModuleOptionAttributeValuesMap()
    throws TorqueException
    {
        LinkedMap result = null;
        //Object obj = getCachedObject(GET_MODULE_OPTION_ATTRVALUES_MAP);
        Object obj = ScarabCache.get(this, GET_MODULE_OPTION_ATTRVALUES_MAP); 
        if (obj == null) 
        {        
            List attributes = null;
            Module module = getModule();
            IssueType issueType = getIssueType();
            attributes = issueType.getActiveAttributes(module);
            Map siaValuesMap = getAttributeValuesMap();
            result = new LinkedMap((int)(1.25*attributes.size() + 1));
            for (int i=0; i<attributes.size(); i++)
            {
                String key = ((Attribute)attributes.get(i)).getName().toUpperCase();
                AttributeValue aval;
                if (siaValuesMap.containsKey(key))
                {
                    aval = (AttributeValue)siaValuesMap.get(key);
                }
                else 
                {
                    Attribute attr = (Attribute)attributes.get(i);
                    aval           = AttributeValue.getNewInstance(attr, this);
                    addAttributeValue(aval);
                }
                if(aval.getOptionId() != null)
                {
                    result.put(key, aval);
                }
            }
            //putCachedObject(result, GET_MODULE_OPTION_ATTRVALUES_MAP);
            ScarabCache.put(result, this, GET_MODULE_OPTION_ATTRVALUES_MAP);
        }
        else
        {
            result = (LinkedMap)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void addAttributeValue(AttributeValue aval)
       throws TorqueException
    {
        List avals = getAttributeValues();
        if (!avals.contains(aval)) 
        {
            super.addAttributeValue(aval);
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getAttributeValue(String attributeName)
        throws TorqueException
    {
        Attribute attribute = Attribute.getInstance(attributeName);
        AttributeValue result;
        if(attribute == null)
        {
            result = null;
        }
        else
        {
            result = getAttributeValue(attribute);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getAttributeValue(int id)
        throws TorqueException
    {
        Attribute attribute = Attribute.getInstance(id);
        return getAttributeValue(attribute);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getAttributeValue(Attribute attribute)
       throws TorqueException
    {
        AttributeValue result = null;
        Object obj = ScarabCache.get(this, GET_ATTRVALUE, attribute); 
        if (obj == null) 
        {        
            if (isNew()) 
            {
                List avals = getAttributeValues();
                if (avals != null) 
                {
                    Iterator i = avals.iterator();
                    while (i.hasNext()) 
                    {
                        AttributeValue tempAval = (AttributeValue)i.next();
                        if (tempAval.getAttribute().equals(attribute)) 
                        {
                            result = tempAval;
                            break;
                        }
                    }
                }
            }
            else 
            {            
                Criteria crit = new Criteria(2)
                    .add(AttributeValuePeer.ISSUE_ID, getIssueId())        
                    .add(AttributeValuePeer.DELETED, false)        
                    .add(AttributeValuePeer.ATTRIBUTE_ID, 
                         attribute.getAttributeId());
                
                List avals = getAttributeValues(crit);
                if (avals.size() > 0)
                {
                    result = (AttributeValue)avals.get(0);
                }
                if (avals.size() > 1)
                {
                    getLog().error("getAttributeValue(): Error when retrieving attribute values of attribute. Expected 1 and found " + avals.size() + ". List follows: " + avals);
                }
            }
            ScarabCache.put(result, this, GET_ATTRVALUE, attribute);
        }
        else 
        {
            result = (AttributeValue)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getAttributeValues(Integer id)
       throws TorqueException
    {
        Attribute attribute = Attribute.getInstance(id);
        return getAttributeValues(attribute);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getAttributeValues(final Attribute attribute)
       throws TorqueException
    {
        List aval = (List)IssueManager.getMethodResult().get(this, GET_ATTRVALUES, attribute); 
        if (aval == null) 
        {        
            if (isNew()) 
            {
                final List avals = getAttributeValues();
                aval = new ArrayList();
                if (avals != null) 
                {
                    final Iterator i = avals.iterator();
                    while (i.hasNext()) 
                    {
                        final AttributeValue tempAval = (AttributeValue)i.next();
                        if (tempAval.getAttribute().equals(attribute)) 
                        {
                            aval.add(tempAval);
                        }
                    }
                }
            }
            else 
            {            
                final Criteria crit = new Criteria(2)
                    .add(AttributeValuePeer.DELETED, false)        
                    .add(AttributeValuePeer.ATTRIBUTE_ID, 
                         attribute.getAttributeId());
                
                aval = getAttributeValues(crit);
                IssueManager.getMethodResult().put(aval, this, GET_ATTRVALUES, attribute);
            }
        }
        return aval;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isAttributeValue(AttributeValue attVal)
       throws TorqueException
    {
        boolean isValue = false;
        List attValues = getAttributeValues(attVal.getAttribute());
        if (attValues.contains(attVal))
        {
            isValue = true;
        }
        return isValue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private AttributeValue getAttributeValueWithValue(Attribute att, String strVal, Integer numVal)
    	throws TorqueException
    {
        AttributeValue val = null;
        boolean bFound = false;
        List attValues = getAttributeValues(att);
        for (Iterator it = attValues.iterator(); !bFound && it.hasNext(); )
        {
			val = (AttributeValue)it.next();
			if (strVal != null)
			    bFound = val.getValue().equals(strVal);
			else if (!bFound && numVal != null)
			    bFound = val.getNumericValue().equals(numVal);
        }
        return val;        
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Map getAttributeValuesMap() throws TorqueException
    {
        Map result = null;
        Object obj = getCachedObject(GET_ATTRIBUTE_VALUES_MAP); 
        if (obj == null) 
        {
            final Criteria crit = new Criteria(2)
                .add(AttributeValuePeer.DELETED, false);        
            final List siaValues = getAttributeValues(crit);
            result = new HashMap((int)(1.25*siaValues.size() + 1));
            for (Iterator i = siaValues.iterator(); i.hasNext(); )
            {
                final AttributeValue att = (AttributeValue) i.next();
                result.put(att.getAttribute().getName().toUpperCase(), att);
            }

            putCachedObject(result, GET_ATTRIBUTE_VALUES_MAP);
        }
        else
        {
            result = (Map)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Map getAllAttributeValuesMap() 
        throws TorqueException
    {
        Map moduleAtts = getModuleAttributeValuesMap();
        Map issueAtts = getAttributeValuesMap();
        Map allValuesMap = new HashMap((int)(1.25*(moduleAtts.size() + 
                                            issueAtts.size())+1));

        allValuesMap.putAll(moduleAtts);
        allValuesMap.putAll(issueAtts);
        return allValuesMap;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean containsMinimumAttributeValues()
        throws TorqueException
    {
        List attributes = getIssueType()
            .getRequiredAttributes(getModule());

        boolean result = true;
        LinkedMap avMap = getModuleAttributeValuesMap();
        MapIterator i = avMap.mapIterator();
        while (i.hasNext()) 
        {
            AttributeValue aval = (AttributeValue)avMap.get(i.next());
            
            if (aval.getOptionId() == null && aval.getValue() == null) 
            {
                for (int j=attributes.size()-1; j>=0; j--) 
                {
                    if (aval.getAttribute().getPrimaryKey().equals(
                         ((Attribute)attributes.get(j)).getPrimaryKey())) 
                    {
                        result = false;
                        break;
                    }                    
                }
                if (!result) 
                {
                    break;
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getEligibleUsers(Attribute attribute)
        throws TorqueException, ScarabException
    {
        ScarabUser[] users = getModule().getEligibleUsers(attribute);
        // remove those already assigned
        List assigneeAVs = getAttributeValues(attribute);
        if (users != null && assigneeAVs != null) 
        {        
            for (int i=users.length-1; i>=0; i--) 
            {
                for (int j=assigneeAVs.size()-1; j>=0; j--) 
                {
                    AttributeValue av = (AttributeValue)assigneeAVs.get(j);
                    Integer avUserId = av.getUserId();
                    Integer userUserId = users[i].getUserId();
                    if ( av != null && avUserId != null && 
                         userUserId != null && 
                         avUserId.equals(userUserId))
                    {
                        users[i] = null;
                        break;
                    }
                }
            }
        }

        List eligibleUsers = new ArrayList(users.length);
        for (int i=0; i<users.length; i++) 
        {
            if (users[i] != null)
            {
                eligibleUsers.add(users[i]);
            }
        }

        return eligibleUsers;
    }
              
// in java/org/tigris/scarab/om/Issue.java
protected Set<ScarabUser> getUsersToEmail(String action, Issue issue, Set<ScarabUser> users)
        throws TorqueException
    {
        if (users == null)
        {
            users = new HashSet<ScarabUser>(1);
        }

        Module module = getModule();

        ScarabUser createdBy = issue.getCreatedBy();
        if (createdBy != null && !users.contains(createdBy) &&
            AttributePeer.EMAIL_TO.equals(action) &&
               createdBy.hasPermission(ScarabSecurity.ISSUE__ENTER, module))
        {
            users.add(createdBy);
        }

        Criteria crit = new Criteria()
            .add(AttributeValuePeer.ISSUE_ID, issue.getIssueId())
            .addJoin(AttributeValuePeer.ATTRIBUTE_ID,
                     AttributePeer.ATTRIBUTE_ID)
            .add(AttributePeer.ACTION, action)
            .add(RModuleAttributePeer.MODULE_ID, getModuleId())
            .add(RModuleAttributePeer.ISSUE_TYPE_ID, getTypeId())
            .add(AttributeValuePeer.DELETED, 0)
            .add(RModuleAttributePeer.ACTIVE, true)
            .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                     AttributeValuePeer.ATTRIBUTE_ID);
        List userAttVals = AttributeValuePeer.doSelect(crit);
        for (Iterator i = userAttVals.iterator(); i.hasNext(); )
        {
            AttributeValue attVal = (AttributeValue) i.next();
            try
            {
                ScarabUser su = ScarabUserManager
                    .getInstance(attVal.getUserId());
                if (!users.contains(su)
                    && su.hasPermission(attVal.getAttribute().getPermission(),
                                        module))
                {
                    users.add(su);
                }
            }
            catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
        }
        return users;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Set<ScarabUser> getAllUsersToEmail(String action) throws TorqueException
    {
        Set<ScarabUser> result = null;
        Object obj = ScarabCache.get(this, GET_ALL_USERS_TO_EMAIL, action); 
        if (obj == null) 
        {        
            Set<ScarabUser> users = new HashSet<ScarabUser>();
            try
            {
                users = getUsersToEmail(action, this, users);
                List children = getChildren();
                for (int i=0;i<children.size();i++)
                {
                    Issue depIssue = IssueManager.getInstance
                        (((Depend) children.get(i)).getObserverId());
                    users = getUsersToEmail(action, depIssue, users);
                }
                result = users;
            }
            catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            ScarabCache.put(result, this, GET_ALL_USERS_TO_EMAIL, action);
        }
        else 
        {
            result = (Set)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getUserAttributeValue(final ScarabUser user, 
            final Attribute attribute)
        throws TorqueException
    {
        AttributeValue result = null;
        Object obj = getCachedObject(GET_USER_ATTRIBUTEVALUE,
            attribute.getAttributeId(), user.getUserId()); 
        if (obj == null) 
        {
            final Criteria crit = new Criteria()
                .add(AttributeValuePeer.ATTRIBUTE_ID, attribute.getAttributeId())
                .add(AttributeValuePeer.ISSUE_ID, getIssueId())
                .add(AttributeValuePeer.USER_ID, user.getUserId())
                .add(AttributeValuePeer.DELETED, 0);
            final List resultList = AttributeValuePeer.doSelect(crit);
            if (resultList != null && resultList.size() == 1)
            {
                result = (AttributeValue)resultList.get(0);
            }
            putCachedObject(result, GET_USER_ATTRIBUTEVALUE, 
                attribute.getAttributeId(), user.getUserId());
        }
        else 
        {
            result = (AttributeValue)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getUserAttributeValues() throws TorqueException
    {
        return getUserAttributeValues(null);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ScarabUser getFirstAssignedTo() throws TorqueException
    {
        String assignedToAttributeName = Environment.getConfigurationProperty("scarab.common.assignedTo", "assignedTo");
        List<AttributeValue> allAssignedUsers = getUserAttributeValues();
        Iterator<AttributeValue> iter = allAssignedUsers.iterator();
        ScarabUser result = null;
        while(iter.hasNext())
        {
            AttributeValue attval = iter.next();
            String attributeName = attval.getAttribute().getName();
            if(attributeName.equals(assignedToAttributeName))
            {
                result = attval.getScarabUser();
                break;
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getUserAttributeValues(final ScarabUser user) throws TorqueException
    {
        List result = null;
        Object obj = null;
        obj = getCachedUserAttributeValues(user);
        
        if (obj == null)
        {
            List attributeList = getModule().getUserAttributes(getIssueType(), true);
            List attributeIdList = new ArrayList();
            
            for (int i=0; i<attributeList.size(); i++) 
            {
                Attribute att = (Attribute) attributeList.get(i);
                attributeIdList.add(att.getAttributeId());
            }
            
            if(!attributeIdList.isEmpty())
            {
                Criteria crit = new Criteria()
                    .addIn(AttributeValuePeer.ATTRIBUTE_ID, attributeIdList)
                    .add(AttributeValuePeer.ISSUE_ID, getIssueId())
                    .add(AttributeValuePeer.DELETED, 0);
                if(user != null)
                {
                    crit.add(AttributeValuePeer.USER_ID, user.getUserId());
                }
                result = AttributeValuePeer.doSelect(crit);
            }
            else 
            {
                result = new ArrayList(0);
            }
            
            putCachedUserAttributeValues(user, result);
        }
        else
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getInitialActivitySet()
        throws TorqueException
    {
        ActivitySet activitySet = getActivitySetRelatedByCreatedTransId();
        if (activitySet == null) 
        {
            Log.get().warn("Creation ActivitySet is null for " + this);
        }
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Date getCreatedDate()
        throws TorqueException
    {
        ActivitySet creationSet = getActivitySetRelatedByCreatedTransId();
        Date result = null;
        if (creationSet == null) 
        {
            getLog().warn("Issue " + getUniqueId() + " (pk=" + getIssueId() +
                           ") does not have a creation ActivitySet");
        }
        else 
        {
            result = creationSet.getCreatedDate();
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ScarabUser getCreatedBy()
        throws TorqueException
    {
        ActivitySet creationSet = getActivitySetRelatedByCreatedTransId();
        ScarabUser result = null;
        if (creationSet == null) 
        {
            getLog().warn("Issue " + getUniqueId() + " (pk=" + getIssueId() +
                           ") does not have a creation ActivitySet");
        }
        else 
        {
            result = creationSet.getScarabUser();
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isCreatingUser(ScarabUser user)
         throws TorqueException
    {
        ActivitySet creationSet = getActivitySetRelatedByCreatedTransId();
        boolean result = false;
        if (creationSet == null) 
        {
            getLog().warn("Issue " + getUniqueId() + " (pk=" + getIssueId() +
                           ") does not have a creation ActivitySet");
        }
        else 
        {
            result = creationSet.getCreatedBy().equals(user.getUserId());
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getLastActivitySet()
        throws TorqueException
    {
        ActivitySet t = null;
        if (!isNew()) 
        {
            Object obj = ScarabCache.get(this, GET_LAST_TRANSACTION, this.getLastTransId());
            if (obj == null) 
            {        
                Criteria crit = new Criteria();
                crit.addJoin(ActivitySetPeer.TRANSACTION_ID, 
                         ActivityPeer.TRANSACTION_ID);
                crit.add(ActivityPeer.ISSUE_ID, getIssueId());
                Integer[] typeIds = {ActivitySetTypePeer.EDIT_ISSUE__PK, 
                                       ActivitySetTypePeer.MOVE_ISSUE__PK};
                crit.addIn(ActivitySetPeer.TYPE_ID, typeIds);
                // there could be multiple attributes modified during the 
                // creation which will lead to duplicates
                crit.setDistinct();
                crit.addDescendingOrderByColumn(ActivitySetPeer.CREATED_DATE);
                List activitySets = ActivitySetPeer.doSelect(crit);
                if (activitySets.size() > 0) 
                {
                    t = (ActivitySet)activitySets.get(0);
                }
                ScarabCache.put(t, this, GET_LAST_TRANSACTION, this.getLastTransId());
            }
            else 
            {
                t = (ActivitySet)obj;
            }
        }
        return t;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Date getModifiedDate()
        throws TorqueException
    {
        Date result = null;
        if (!isNew()) 
        {
            ActivitySet t = getLastActivitySet();
            if (t == null)
            {
                result = getCreatedDate();
            }
            else 
            {
                result = t.getCreatedDate();
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public long getHoursIdle() throws TorqueException, ParseException
    {
        Date now = new Date();
        Date date = null;
        Date onHoldUntil = null;
        long diffHours = 0;

        if (!isNew()) 
        {
            boolean onHold = isOnHold();
            if(onHold)
            {
                onHoldUntil = getOnHoldUntil(); // on Hold until this date
                if(onHoldUntil == null)
                {
                    return 0; // we are on hold but there is no end date, so we wait forever.
                }
                diffHours = (now.getTime() - onHoldUntil.getTime()) / (1000*60*60);
                if(diffHours < 0)
                {
                    return 0; // onHoldDate not yet reached, so we are not idle by definition
                }
            }
            ActivitySet t = getLastActivitySet();
            if (t == null)
            {
                date = getCreatedDate();
            }
            else 
            {
                date = t.getCreatedDate();
            }
            
            if(onHold)
            {
                if (date.before(onHoldUntil))
                {
                    // The date of last activity was before the onHoldUntil date
                    // In that case we count the end of the onHold period as the
                    // event.
                    date = onHoldUntil;
                }
            }
            
        }
        // Return the difference in hours between now and the last date of activities:
        diffHours = (now.getTime() - date.getTime()) / (1000*60*60);
        return diffHours;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ScarabUser getModifiedBy()
        throws TorqueException
    {
        ScarabUser result = null;
        if (!isNew()) 
        {
            ActivitySet t = getLastActivitySet();
            if (t == null)
            {
                result = getCreatedBy();
            }
            else 
            {
                result = ScarabUserManager
                    .getInstance(t.getCreatedBy());
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public int getCommentsCount() throws TorqueException
    {
        return getComments(true).size();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isCommentsLong() throws TorqueException
    {
        return (getCommentsCount() > getCommentsLimit());
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getComments(boolean full) throws TorqueException
    {
        List result = null;
        Boolean fullBool = (full ? Boolean.TRUE : Boolean.FALSE);
        Object obj = getCachedObject(GET_COMMENTS, fullBool);
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(AttachmentPeer.ISSUE_ID, getIssueId())
                .addJoin(AttachmentTypePeer.ATTACHMENT_TYPE_ID,
                         AttachmentPeer.ATTACHMENT_TYPE_ID)
                .add(AttachmentTypePeer.ATTACHMENT_TYPE_ID, 
                     Attachment.COMMENT__PK)
                .addDescendingOrderByColumn(AttachmentPeer.CREATED_DATE);
            if (!full)
            {
                crit.setLimit(getCommentsLimit());
            }
            result = AttachmentPeer.doSelect(crit);
            putCachedObject(result, GET_COMMENTS, fullBool);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getUrls() throws TorqueException
    {
        List result = null;
        Object obj = getCachedObject(GET_URLS);
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(AttachmentPeer.ISSUE_ID, getIssueId())
                .addJoin(AttachmentTypePeer.ATTACHMENT_TYPE_ID,
                         AttachmentPeer.ATTACHMENT_TYPE_ID)
                .add(AttachmentTypePeer.ATTACHMENT_TYPE_ID, 
                     Attachment.URL__PK)
                .add(AttachmentPeer.DELETED, 0);
            result = AttachmentPeer.doSelect(crit);
            putCachedObject(result, GET_URLS);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getExistingAttachments() throws TorqueException
    {
        List result = null;
        Object obj = getCachedObject(GET_EXISTING_ATTACHMENTS); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(AttachmentPeer.ISSUE_ID, getIssueId())
                .addJoin(AttachmentTypePeer.ATTACHMENT_TYPE_ID,
                         AttachmentPeer.ATTACHMENT_TYPE_ID)
                .add(AttachmentTypePeer.ATTACHMENT_TYPE_ID, 
                     Attachment.FILE__PK)
                .add(AttachmentPeer.DELETED, 0);
            result = AttachmentPeer.doSelect(crit);
            putCachedObject(result, GET_EXISTING_ATTACHMENTS);
        }
        else 
        {
            result = (List)obj;
        }
        return result;        
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getActivitiesWithNullEndDate(Attribute attribute)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_NULL_END_DATE, attribute);
        if (obj == null)
        {
            Criteria crit = new Criteria();
            crit.add(ActivityPeer.ISSUE_ID, this.getIssueId());
            crit.add(ActivityPeer.ATTRIBUTE_ID, attribute.getAttributeId());
            crit.add(ActivityPeer.END_DATE, null);
            result = ActivityPeer.doSelect(crit);
            ScarabCache.put(result, this, GET_NULL_END_DATE, attribute);
        }
        else
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public int getHistoryLimit() throws TorqueException
    {
        RModuleIssueType rmit = getModule().getRModuleIssueType(getIssueType());
        if (rmit != null)
        {
            return rmit.getHistory();
        }
        else
        {
            return 5;
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isHistoryLong() throws TorqueException
    {
        return isHistoryLong(getHistoryLimit());
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isHistoryLong(int limit) throws TorqueException
    {
        return (getActivity(true).size() > limit);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getActivity(ScarabUser user) throws TorqueException  
    {
        return getActivity(false, getHistoryLimit(), user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getActivity(int limit, ScarabUser user) throws TorqueException  
    {
        return getActivity(false, limit, user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getActivity(boolean fullHistory, ScarabUser user) throws TorqueException
    {
        return getActivity(fullHistory, getHistoryLimit(), user);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getActivity(boolean fullHistory) throws TorqueException  
    {
        return this.getActivity(fullHistory, null);
    }
              
// in java/org/tigris/scarab/om/Issue.java
private List getActivity(boolean fullHistory, int limit) throws TorqueException
    {
        return this.getActivity(fullHistory, limit, null);
    }
              
// in java/org/tigris/scarab/om/Issue.java
private List getActivity(boolean fullHistory, int limit, ScarabUser user) throws TorqueException  
    {
        List result = null;
        Boolean fullHistoryObj = fullHistory ? Boolean.TRUE : Boolean.FALSE;
        Object obj = getCachedObject(GET_ACTIVITY, fullHistoryObj,
                                     new Integer(limit)); 
        if (obj == null)
        {
            Criteria crit = new Criteria()
                .add(ActivityPeer.ISSUE_ID, getIssueId())
                .addAscendingOrderByColumn(ActivityPeer.TRANSACTION_ID);
            if (!fullHistory)
            {
                crit.setLimit(limit);
            }
            result = ActivityPeer.doSelect(crit);
            putCachedObject(result, GET_ACTIVITY, 
                            fullHistoryObj, new Integer(limit));
        }
        else 
        {
            result = (List)obj;
        }

        /**
         * Filter all activities related to attributegroups restricted to any role
         * to which current user does not belong to.
         * 
         */
        final List visibleActivities = new ArrayList();
        for (Iterator it = result.iterator(); it.hasNext(); )
        {
            final Activity act = (Activity)it.next();
            final Attribute attr = act.getAttribute();
            if (isAttributeVisible(attr, user))
            {
                visibleActivities.add(act);
            }
        }
        return visibleActivities;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void addActivity(Activity activity) throws TorqueException  
    {
        List activityList = null;
        try
        {
            activityList = getActivity(true);
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        super.addActivity(activity);
        if (!activityList.contains(activity))
        {
            activityList.add(activity);
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getActivitySets()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_TRANSACTIONS);
        if (obj == null)
        {
            Criteria crit = new Criteria();
            crit.add(ActivityPeer.ISSUE_ID, getIssueId());
            crit.addJoin(ActivitySetPeer.TRANSACTION_ID, ActivityPeer.TRANSACTION_ID);
            crit.setDistinct();
            result = ActivitySetPeer.doSelect(crit);
            ScarabCache.put(result, this, GET_TRANSACTIONS);
        }
        else
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isAttributeVisible(final Attribute attr, final ScarabUser user)
        throws TorqueException
    {
        final List/*<AttributeGroup>*/ attrGroups = this.getIssueType().getAttributeGroups();

        boolean foundInAnyGroup = false;
        boolean visibleInFoundGroup = false;
        
        for(Iterator itAny = attrGroups.iterator(); !foundInAnyGroup && itAny.hasNext();)
        {
            final AttributeGroup ag = (AttributeGroup)itAny.next();
            if(getModuleId().equals(ag.getModuleId()) && ag.getAttributes().contains(attr))
            {
                foundInAnyGroup = true;
                if(null == ag.getViewRoleId() || ag.isVisible4User(user))
                {
                    visibleInFoundGroup = true;
                }
            }
        }
        return !foundInAnyGroup || visibleInFoundGroup;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getActivitySet(final ScarabUser user, 
            final Attachment attachment,
            final Integer type)
        throws TorqueException,ScarabException
    {
        ActivitySet activitySet = null;
        if (attachment == null)
        {
            activitySet = ActivitySetManager
                .getInstance(type, user);
        }
        else
        {
            activitySet = ActivitySetManager
                .getInstance(type, user, attachment);
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getActivitySet(ScarabUser user, Integer type)
        throws TorqueException, ScarabException
    {
        return getActivitySet(user, null, type);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getAllDependencies()
        throws TorqueException
    {
        List dependencies = new ArrayList();
        dependencies.addAll(getChildren());
        dependencies.addAll(getParents());
        return dependencies;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getChildren() throws TorqueException  
    {
        return getChildren(true);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getChildren(boolean hideDeleted) throws TorqueException  
    {
        List result = null;
        Boolean hide = hideDeleted ? Boolean.TRUE : Boolean.FALSE;
        Object obj = getCachedObject(GET_CHILDREN, hide); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(DependPeer.OBSERVED_ID, getIssueId());
            if (hideDeleted)
            {
                crit.add(DependPeer.DELETED, false);
            }
            result = DependPeer.doSelect(crit);
            putCachedObject(result, GET_CHILDREN, hide);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getParents() throws TorqueException  
    {
        return getParents(true);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getParents(boolean hideDeleted) throws TorqueException  
    {
        List result = null;
        Boolean hide = hideDeleted ? Boolean.TRUE : Boolean.FALSE;
        Object obj = getCachedObject(GET_PARENTS, hide); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(DependPeer.OBSERVER_ID, getIssueId());
            if (hideDeleted)
            {
                crit.add(DependPeer.DELETED, false);
            }
            result = DependPeer.doSelect(crit);
            putCachedObject(result, GET_PARENTS, hide);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getAllDependencyTypes() throws TorqueException
    {
        return DependTypeManager.getAll();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doAddDependency(ActivitySet activitySet, Depend depend, 
                                       Issue childIssue, ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check whether the entered issue is already dependent on this
        // Issue. If so, then throw an exception because we don't want
        // to add it again.
        Depend prevDepend = this.getDependency(childIssue, true);
        if (prevDepend != null)
        {
            throw new ScarabException(L10NKeySet.DependencyExists);
        }

        // we definitely want to do an insert here so force it.
        depend.setNew(true);
        depend.setDeleted(false);
        depend.save();

        Attachment comment = depend.getDescriptionAsAttachment(user, this);
        activitySet = attachActivitySet(activitySet, user, comment);

        // Save activity record for the parent issue
        ActivityManager
            .createAddDependencyActivity(this, activitySet, depend);

        // Save activity record for the child issue
        ActivityManager
            .createAddDependencyActivity(childIssue, activitySet, depend);

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Depend getDependency(Issue potentialDependency) throws TorqueException
    {
        return getDependency(potentialDependency, true);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Depend getDependency(Issue potentialDependency, boolean hideDeleted) throws TorqueException
    {
        Depend result = null;
        Object obj = ScarabCache.get(this, GET_DEPENDENCY, potentialDependency);
        if (obj == null)
        {

            // Determine if this issue is a parent to the potentialDependency
            Criteria crit = new Criteria(2)
                .add(DependPeer.OBSERVED_ID, getIssueId())
                .add(DependPeer.OBSERVER_ID, potentialDependency.getIssueId());
            if (hideDeleted)
            {
                crit.add(DependPeer.DELETED, false);
            }

            List childIssues = DependPeer.doSelect(crit);
            // A system invariant is that we will get one and only one
            // record back.
            if (!childIssues.isEmpty())
            {
                result = (Depend)childIssues.get(0);
            }
            else
            {
                // Determine if this issue is a child to the potentialDependency
                Criteria crit2 = new Criteria(2)
                    .add(DependPeer.OBSERVER_ID, getIssueId())
                    .add(DependPeer.OBSERVED_ID, potentialDependency.getIssueId());
                if (hideDeleted)
                {
                    crit2.add(DependPeer.DELETED, false);
                }
                List parentIssues = DependPeer.doSelect(crit2);
                if (!parentIssues.isEmpty())
                {
                    result = (Depend)parentIssues.get(0);
                }
            }

            if (result != null)
            {
                ScarabCache.put(result, this, GET_DEPENDENCY, potentialDependency);
            }
        }
        else
        {
            result = (Depend)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void save(Connection dbCon)
        throws TorqueException
    {
        Module module = getModule();
        if (!module.allowsIssues() || (isNew() && !module.allowsNewIssues())) 
        {
            throw new UnsupportedOperationException(module.getName() + 
                " does not allow issues."); //EXCEPTION
        }
        
        // remove unset AttributeValues before saving
        List attValues = getAttributeValues();
        // reverse order since removing from list
        for (int i=attValues.size()-1; i>=0; i--) 
        {
            AttributeValue attVal = (AttributeValue) attValues.get(i);
            if (!attVal.isSet()) 
            {
                attValues.remove(i);
            }
        }

        if (isNew())
        {
            // set the issue id
            setIdDomain(module.getScarabInstanceId());
            setIdPrefix(module.getCode());

            // for an enter issue template, do not give issue id
            // set id count to -1 so does not show up as an issue
            if (isTemplate())
            { 
                setIdCount(-1);
            }
            else
            {
                try
                {
                    final int suggestedID = getIdCount();
                    if (suggestedID != 0) {
                        // Force the next available issue ID to be the
                        // nominated value, if not out of sequence.
                        // TODO: assert that this issue doesn't already exist
                        // In this case, just skip the next action.
                        setNextIssueId(dbCon, suggestedID);
                    }
                    
                    // Set the ID to the next available value.
                    setIdCount(getNextIssueId(dbCon));
                }
                catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        if(  getActivitySetRelatedByLastTransId()==null
           ||getActivitySetRelatedByCreatedTransId()==null)
        {
            throw new RuntimeException("Created or Last ActivitySet must not be null.");
        }
        super.save(dbCon);
    }
              
// in java/org/tigris/scarab/om/Issue.java
private int getNextIssueId(Connection con)
        throws TorqueException, ScarabException
    {
        int id = -1;
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        try
        {
            id = idbroker.getIdAsInt(con, key);
        }
        catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
        return id;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private void setNextIssueId(Connection con, int newID)
        throws TorqueException, ScarabException
    {
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        int nextID = 1;
        
        synchronized (idbroker)
        {
            try
            {
                // Check if the ID table is available and get the next ID
                nextID = idbroker.getIdAsInt(con, key);
            }
            catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }

            if (nextID > newID) {
                getLog()
                    .error("New issue ID "+ newID
                    + "is out of sequence. Must be at least " + nextID);
            }
            else
            {
                try
                {
                    // Now set the next available ID in the table
                    setIdTableKey(con, newID);
                }
                catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
private String getIdTableKey()
        throws TorqueException
    {
        Module module = getModule();        
        String prefix = module.getCode();

        String domain = module.getScarabInstanceId();            
        if (domain != null && domain.length() > 0) 
        { 
            prefix = domain + "-" + prefix;
        }
        return prefix;
    }
              
// in java/org/tigris/scarab/om/Issue.java
private void saveIdTableKey(final Connection dbCon, final int nextID)
        throws TorqueException
    {
        int id = 0;
        final DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        final IDBroker idbroker = dbMap.getIDBroker();
        final String idTable = IDBroker.TABLE_NAME.substring(0, 
        IDBroker.TABLE_NAME.indexOf('.'));
        try
        {
            id = idbroker.getIdAsInt(dbCon, idTable);
        }
        catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }

        final String key = getIdTableKey();

        // FIXME: UGLY! IDBroker doesn't have a Peer yet.
        final String sql = "insert into " + idTable 
         + " (ID_TABLE_ID,TABLE_NAME,NEXT_ID,QUANTITY) "
         + " VALUES (" + id + ",'" + key + "'," + nextID + ",1)" ;
        BasePeer.executeStatement(sql, dbCon);
    }
              
// in java/org/tigris/scarab/om/Issue.java
private void setIdTableKey(final Connection dbCon, int id)
        throws TorqueException
    {
        final String key = getIdTableKey();

        // FIXME: UGLY! IDBroker doesn't have a Peer yet.
        final String sql = "update ID_TABLE set NEXT_ID=" + id
            + " where TABLE_NAME='" + key + "'";
        BasePeer.executeStatement(sql, dbCon);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public IssueTemplateInfo getTemplateInfo() 
          throws TorqueException
    {
        IssueTemplateInfo result = null;
        Object obj = ScarabCache.get(this, GET_TEMPLATEINFO); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(1);
            crit.add(IssueTemplateInfoPeer.ISSUE_ID, getIssueId());
            result = (IssueTemplateInfo)IssueTemplateInfoPeer
                .doSelect(crit).get(0);
            ScarabCache.put(result, this, GET_TEMPLATEINFO);
        }
        else 
        {
            result = (IssueTemplateInfo)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getUnsetRequiredAttrs(Module newModule, IssueType newIssueType)
        throws TorqueException
    {
        List attrs = new ArrayList();
        if (!getIssueType().getIssueTypeId()
            .equals(newIssueType.getIssueTypeId())
            || !getModule().getModuleId().equals(newModule.getModuleId()))
        {
            List requiredAttributes = 
                newIssueType.getRequiredAttributes(newModule);
            Map attrValues = getAttributeValuesMap();

            for (Iterator i = requiredAttributes.iterator(); i.hasNext(); )
            {
                Attribute attr = (Attribute)i.next();
                if (!attrValues.containsKey(attr.getName().toUpperCase()))
                {
                    attrs.add(attr);
                }
            }
        }
        return attrs;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Issue move(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user,
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
    	
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // If moving to a new issue type, just change the issue type id
        // otherwise, create fresh issue
        if (getModule().getModuleId().equals(newModule.getModuleId())
            && !getIssueType().getIssueTypeId().equals(newIssueType.getIssueTypeId()))
        {
            newIssue = this;
            newIssue.setIssueType(newIssueType);
            newIssue.save();
        }
        else
        {
            newIssue = newModule.getNewIssue(newIssueType);
        }

        if (newIssue != this)//new issue is not same issue instance as old issue
        {
            // mark issue as moved
            setMoved(true);
            save();

            //add new transaction to new issue
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();      

            // copy attachments: comments/files etc.
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                String oldFilePath = oldA.getFullPath();
                oldA.setIssueId(newIssue.getIssueId());
                oldA.save();
                
                // move file attachment, too
                if (Attachment.FILE__PK.equals(oldA.getTypeId())
                		&& !newIssue.getUniqueId().equals(this.getUniqueId()))
                {
                    try
                    {
                        oldA.copyFileFromTo(oldFilePath, oldA.getFullPath());//copy
                        File f = new File(oldFilePath);//delete old one from disk
                        f.delete();
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }

            // Copy over activity sets for the source issue's previous,
            // and adapt them to new issue
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();

                // If activity set has an attachment, make a copy for new issue
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    // iterate over and move transaction's activities
                    final Activity a = (Activity)j.next();
                    
                    // Only copy transactions that are records of previous move/copies
                    // or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // will be saved when attachments and dependencies are copied.
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                            || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                    	att.setIssueId(newIssue.getIssueId());
                                    	att.setActivity(a);
                                    	att.startActivitySet(as);
                                    	att.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            //adapt all misc activities from old issue
            Iterator iterActivities = getActivitys().iterator();
            while(iterActivities.hasNext()){
            	Activity act = (Activity)iterActivities.next();
            	act.setIssue(newIssue);
            	act.save();
            	newIssue.getActivity(true).add(act); // ?
            }
            
            // Adjust dependencies if its a new issue id
            // (i.e.. moved to new module)
           final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
        }       
       

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "MovedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());

        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "MovedIssueNote"));
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_MOVED,
                                getUniqueId(), newIssue.getUniqueId());

        newIssue.index();
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_MOVED,
                activitySet2, newIssue, user);
        
        return newIssue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Issue copy(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user, 
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // create fresh issue
        newIssue = newModule.getNewIssue(newIssueType);

        if (newIssue != this)
        {
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();

            // Copy over activity sets for the source issue's attribute activities
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();
                ActivitySet newAS = null;
                Attachment newAtt =  null;
                              
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    final Activity a = (Activity)j.next();

                    // Only copy transactions that are records of previous move/copies
                    // Or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // Will be saved when attachments and dependencies are copied
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                        || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // iterate over and copy transaction's activities
                       
                        if(newAS == null){
                        	
                        	 // If old activity set has an attachment, make a copy for new issue
                            if (as.getAttachmentId() != null)
                            {
                                newAtt = as.getAttachment().copy();
                                newAtt.save();
                            }
                        	
            				//init and store new activity set/transaction
                            newAS = new ActivitySet();
                            newAS.setTypeId(as.getTypeId());
                            if (newAtt != null)
                            {
                                newAS.setAttachmentId(newAtt.getAttachmentId());
                            }
                            newAS.setCreatedBy(as.getCreatedBy());
                            newAS.setCreatedDate(as.getCreatedDate());
                            newAS.save();
                        }
                        
                        final Activity newA = a.copy(newIssue, newAS);
                        
                        newIssue.getActivity(true).add(newA);
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                        final AttributeValue newAttVal = att.copy();
                                        newAttVal.setIssueId(newIssue.getIssueId());                                        
                                        newAttVal.setActivity(newA);
                                        newAttVal.startActivitySet(newAS);
                                        newAttVal.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            // add dependencies newly
            final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
            // copy attachments: comments/files etc. and add them, too
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                final Attachment newA = oldA.copy();
                newA.setIssueId(newIssue.getIssueId());
                newA.save();
                final Activity oldAct = oldA.getActivity();
                if (oldAct != null)
                {
                    final ActivitySet activitySet = newIssue.attachActivitySet(null, user);
                    ActivityManager.createTextActivity(newIssue, activitySet,
                        ActivityType.getActivityType(oldA.getActivity().getActivityType()), newA);
                }
                if (Attachment.FILE__PK.equals(newA.getTypeId()))
                {
                    try
                    {
                        oldA.copyFileTo(newA.getFullPath());
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }
        }

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CopiedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());


        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "CopiedIssueNote"));
        
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        // NOTE: There is no distinction bewteen copy and move actions in ActivitySetTypePeer.
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_COPIED,
                                getUniqueId(), newIssue.getUniqueId());
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_COPIED,
                activitySet2, newIssue, user);
        
        newIssue.index();
        
        return newIssue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getMatchingAttributeValuesList(Module newModule,
                                               IssueType newIssueType)
          throws TorqueException
    {
        List matchingAttributes = new ArrayList();
        Map setMap = this.getAttributeValuesMap();
        for (Iterator iter = setMap.keySet().iterator(); iter.hasNext();)
        {
            AttributeValue aval = (AttributeValue)setMap.get(iter.next());
            List values = getAttributeValues(aval.getAttribute());
            // loop thru the values for this attribute
            for (int i = 0; i<values.size(); i++)
            {
                AttributeValue attVal = (AttributeValue)values.get(i);
                RModuleAttribute modAttr = newModule.
                    getRModuleAttribute(aval.getAttribute(), newIssueType);

                // If this attribute is active for the destination module,
                // Add to matching attributes list
                if (modAttr != null && modAttr.getActive())
                {
                    // If attribute is an option attribute,
                    // Check if attribute option is active for destination module.
                    if (aval instanceof OptionAttribute)
                    {
                        // FIXME: Use select count
                        Criteria crit2 = new Criteria(4)
                            .add(RModuleOptionPeer.ACTIVE, true)
                            .add(RModuleOptionPeer.OPTION_ID, attVal.getOptionId())
                            .add(RModuleOptionPeer.MODULE_ID, newModule.getModuleId())
                            .add(RModuleOptionPeer.ISSUE_TYPE_ID, newIssueType.getIssueTypeId());
                        List modOpt = RModuleOptionPeer.doSelect(crit2);

                        if (!modOpt.isEmpty())
                        {
                            matchingAttributes.add(attVal);
                        }
                    }
                    else if (attVal instanceof UserAttribute)
                    {
                        ScarabUser user = null;
                        try
                        {
                            user = ScarabUserManager.getInstance(attVal.getUserId());
                        }
                        catch (Exception e)
                        {
                            getLog().error(e);
                            e.printStackTrace();
                        }
                        Attribute attr = attVal.getAttribute();
                        ScarabUser[] userArray = newModule.getUsers(attr.getPermission());
                        // If user exists in destination module with this permission,
                        // Add as matching value
                        if (Arrays.asList(userArray).contains(user))
                        {
                            matchingAttributes.add(attVal);
                        }
                    }
                    else
                    {
                        matchingAttributes.add(attVal);
                    }
                }
            }
        }
        return matchingAttributes;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getMatchingAttributeValuesList(String moduleId, String issueTypeId)
          throws TorqueException
    {
         Module module = ModuleManager.getInstance(new Integer(moduleId));
         IssueType issueType = IssueTypeManager.getInstance(new Integer(issueTypeId));
         return getMatchingAttributeValuesList(module, issueType);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getNonMatchingAttributeValuesList(Module newModule,
                                             IssueType newIssueType)
          throws TorqueException
    {
        List nonMatchingAttributes = new ArrayList();
        AttributeValue aval = null;

        Map setMap = this.getAttributeValuesMap();
        for (Iterator iter = setMap.values().iterator(); iter.hasNext();)
        {
            aval = (AttributeValue) iter.next();
            List values = getAttributeValues(aval.getAttribute());
            // loop thru the values for this attribute
            for (Iterator i = values.iterator(); i.hasNext(); )
            {
                AttributeValue attVal = (AttributeValue) i.next();
                RModuleAttribute modAttr = newModule.
                    getRModuleAttribute(aval.getAttribute(), newIssueType);

                // If this attribute is not active for the destination module,
                // Add to nonMatchingAttributes list
                if (modAttr == null || !modAttr.getActive())
                {
                    nonMatchingAttributes.add(attVal);
                }
                else
                {
                    // If attribute is an option attribute, Check if
                    // attribute option is active for destination module.
                    if (attVal instanceof OptionAttribute)
                    {
                        Criteria crit2 = new Criteria(1)
                            .add(RModuleOptionPeer.ACTIVE, true)
                            .add(RModuleOptionPeer.OPTION_ID, attVal.getOptionId())
                            .add(RModuleOptionPeer.MODULE_ID, newModule.getModuleId())
                            .add(RModuleOptionPeer.ISSUE_TYPE_ID, newIssueType.getIssueTypeId());
                        List modOpt = RModuleOptionPeer.doSelect(crit2);

                        if ( modOpt.isEmpty())
                        {
                                nonMatchingAttributes.add(attVal);
                        }
                    }
                    else if (attVal instanceof UserAttribute)
                    {
                        ScarabUser user = null;
                        try
                        {
                            user = ScarabUserManager.getInstance(attVal.getUserId());
                        }
                        catch (Exception e)
                        {
                            Log.get().error("Unable to retrieve user for "
                                            + "attribute", e);
                        }
                        Attribute attr = attVal.getAttribute();
                        ScarabUser[] userArray =
                            newModule.getUsers(attr.getPermission());
                        // If user exists in destination module with
                        // this permission, add as matching value.
                        if (!Arrays.asList(userArray).contains(user))
                        {
                            nonMatchingAttributes.add(attVal);
                        }
                    }
                }
            }
        }
        return nonMatchingAttributes;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getNonMatchingAttributeValuesList(String moduleId, String issueTypeId)
          throws TorqueException
    {
         Module module = ModuleManager.getInstance(new Integer(moduleId));
         IssueType issueType = IssueTypeManager.getInstance(new Integer(issueTypeId));
         return getNonMatchingAttributeValuesList(module, issueType);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void deleteItem(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__DELETE, module)
            || (user.getUserId().equals(getCreatedBy().getUserId()) && isTemplate()))
        {
            setDeleted(true);
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getDefaultTextAttributeValue()
        throws TorqueException
    {
        AttributeValue result = null;
        Object obj = ScarabCache.get(this, GET_DEFAULT_TEXT_ATTRIBUTEVALUE); 
        if (obj == null) 
        {        
            Attribute defaultTextAttribute = 
                getIssueType().getDefaultTextAttribute(getModule());
            if (defaultTextAttribute != null) 
            {
                result = getAttributeValue(defaultTextAttribute);
            }
            ScarabCache.put(result, this, GET_DEFAULT_TEXT_ATTRIBUTEVALUE);
        }
        else 
        {
            result = (AttributeValue)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public String getDefaultText()
        throws TorqueException
    {
        String result = null;
        Object obj = ScarabCache.get(this, GET_DEFAULT_TEXT); 
        if (obj == null) 
        {        
            AttributeValue emailAV = getDefaultTextAttributeValue();
            if (emailAV != null) 
            {
                result = emailAV.getValue();
            }
            if (result == null) 
            {
                ActivitySet activitySet = getInitialActivitySet();
                if (activitySet != null)
                {
                    Attachment reason = activitySet.getAttachment();
                    if (reason != null && reason.getData() != null 
                        && reason.getData().trim().length() > 0) 
                    {
                        result = reason.getData();
                    }        
                }                
            }
            result = (result == null) ? 
                Localization.getString(ScarabConstants.DEFAULT_BUNDLE_NAME,
                                       getLocale(), "NoIssueSummaryAvailable")
                      : result;
            ScarabCache.put(result, this, GET_DEFAULT_TEXT);
        }
        else 
        {
            result = (String)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet assignUser(ActivitySet activitySet,
                                  final ScarabUser assignee, 
                                  final ScarabUser assigner,
                                  final Attribute attribute, 
                                  final Attachment attachment)
        throws TorqueException,ScarabException
    {                
        final UserAttribute attVal = new UserAttribute();

        activitySet = attachActivitySet(activitySet, assigner, attachment);
        attVal.startActivitySet(activitySet);

        ActivityManager
            .createUserActivity(this, attribute, activitySet,
                                null,
                                null, assignee.getUserId());

        // Save user attribute values
        attVal.setIssue(this);
        attVal.setAttributeId(attribute.getAttributeId());
        attVal.setUserId(assignee.getUserId());
        attVal.setValue(assignee.getUserName());
        attVal.save();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet changeUserAttributeValue(ActivitySet activitySet,
                                                final ScarabUser assignee, 
                                                final ScarabUser assigner, 
                                                final AttributeValue oldAttVal,
                                                final Attribute newAttr,
                                                final Attachment attachment)
        throws TorqueException,ScarabException
    {
        activitySet = attachActivitySet(activitySet, assigner, attachment);
        oldAttVal.startActivitySet(activitySet);

        // Save activity record for deletion of old assignment
        ActivityManager
            .createUserActivity(this, oldAttVal.getAttribute(), 
                                activitySet,
                                null,
                                assignee.getUserId(), null);


        // Save activity record for new assignment
        ActivityManager
            .createUserActivity(this, newAttr, activitySet,
                                null,
                                null, assignee.getUserId());

        // Save assignee value
        oldAttVal.setAttributeId(newAttr.getAttributeId());
        oldAttVal.save();
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet deleteUser(ActivitySet activitySet, 
            final ScarabUser assignee, 
            final ScarabUser assigner,
            final AttributeValue attVal, 
            final Attachment attachment)
        throws TorqueException, ScarabException
    {
        activitySet = attachActivitySet(activitySet, assigner, attachment);
        attVal.startActivitySet(activitySet);

        // Save activity record
        ActivityManager
            .createUserActivity(this, attVal.getAttribute(), 
                                activitySet,
                                null,
                                assignee.getUserId(), null);

        // Save assignee value
        attVal.setDeleted(true);
        attVal.save();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doDeleteDependency(ActivitySet activitySet, 
            Depend oldDepend, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final Issue otherIssue = IssueManager
                        .getInstance(oldDepend.getObserverId(), false);
        final Issue thisIssue = IssueManager
                        .getInstance(oldDepend.getObservedId(), false);

        // get the original object so that we do an update
        oldDepend = thisIssue.getDependency(otherIssue);
        oldDepend.setNew(false);
        oldDepend.setDeleted(true);
        oldDepend.save();

        // need to null out the cache entry so that Issue.getDependency()
        // does not try to return the item from the cache
        ScarabCache.put(null, thisIssue, GET_DEPENDENCY, otherIssue);

        Attachment comment = oldDepend.getDescriptionAsAttachment(user, thisIssue);

        activitySet = thisIssue.attachActivitySet(activitySet, user, comment);
        activitySet = otherIssue.attachActivitySet(activitySet, user, comment);

        ActivityManager
            .createDeleteDependencyActivity(thisIssue, activitySet, oldDepend);
        ActivityManager
            .createDeleteDependencyActivity(otherIssue, activitySet, oldDepend);


        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeUrlDescription(ActivitySet activitySet, 
                                              final ScarabUser user,
                                              final Attachment attachment, 
                                              final String oldDescription)
        throws TorqueException, ScarabException
    {
        final String newDescription = attachment.getName();
        if (!oldDescription.equals(newDescription))
        {
            final Object[] args = {
                oldDescription,
                newDescription,
            };
            String desc = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "UrlDescChangedDesc", args);

            if (desc.length() > 248)
            { 
                desc = desc.substring(0,248) + "...";
            }
            activitySet = attachActivitySet(activitySet, user);
            ActivityManager
                .createTextActivity(this, activitySet,
                                    ActivityType.URL_DESC_CHANGED, attachment,
                                    oldDescription, newDescription);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_DESC_CHANGED, activitySet, this, user);                
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeUrlUrl(ActivitySet activitySet, 
            final ScarabUser user,
            final Attachment attachment, 
            final String oldUrl)
        throws TorqueException, ScarabException
    {
        final String newUrl = attachment.getData();
        if (!oldUrl.equals(newUrl))
        {
            final Object[] args = {
                oldUrl, newUrl
            };
            String desc = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "UrlChangedDesc", args);

            if (desc.length() > 248)
            { 
                desc = desc.substring(0,248) + "...";
            }
            activitySet = attachActivitySet(activitySet, user);

            // Save activity record
            ActivityManager.createTextActivity(
                    this,
                    activitySet,
                    ActivityType.URL_CHANGED,
                    attachment,
                    oldUrl,
                    newUrl);

            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_CHANGED, activitySet, this, user);            
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeDependencyType(ActivitySet activitySet,
                                              final Depend oldDepend,
                                              final Depend newDepend, 
                                              final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldName = oldDepend.getDependType().getName();
        final String newName = newDepend.getDependType().getName();

        final boolean rolesHaveSwitched = 
            ( oldDepend.getObserverId().equals(newDepend.getObservedId()) &&
              oldDepend.getObservedId().equals(newDepend.getObserverId())
            );
        final boolean typeHasChanged = 
            ( !newName.equals(oldName));
        
        final boolean isActive = !newDepend.getDeleted();
        
        // check to see if something changed
        // only change dependency type for non-deleted deps
        if ( isActive && ( rolesHaveSwitched || typeHasChanged ) )
        {
            final Issue otherIssue = (newDepend.getObservedId().longValue() != this.getIssueId().longValue()
            		? IssueManager.getInstance(newDepend.getObservedId(), false)
            		: IssueManager.getInstance(newDepend.getObserverId(), false));

            // always delete an old dependency
            oldDepend.setDeleted(true);
            oldDepend.save();
            // always create a new dependency
            newDepend.setNew(true);
            newDepend.save();

            // need to null out the cache entry so that Issue.getDependency()
            // does not try to return the item from the cache
            ScarabCache.put(null, this, GET_DEPENDENCY, otherIssue);

            final Attachment comment = newDepend.getDescriptionAsAttachment(user, this);

            activitySet = attachActivitySet(activitySet, user, comment);
            activitySet = otherIssue.attachActivitySet(activitySet, user, comment);
            
            ActivityManager
                .createChangeDependencyActivity(this, activitySet, newDepend,
                                    oldName, newName);
            ActivityManager
                .createChangeDependencyActivity(otherIssue, activitySet, newDepend,
                                    oldName, newName);
        }
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setInitialAttributeValues(ActivitySet activitySet, 
            Attachment attachment, 
            final HashMap newValues, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check new values for workflow
        final String msg = doCheckInitialAttributeValueWorkflow(newValues, user);
        if (msg != null)
        {
            throw new TorqueException(msg); //EXCEPTION
        }
        
        if (activitySet == null)
        {
            // Save activitySet record
            activitySet = ActivitySetManager
                .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
            activitySet.save();
        }
        setActivitySetRelatedByCreatedTransId(activitySet);

        // enter the values into the activitySet
        final LinkedMap avMap = getModuleAttributeValuesMap(); 
        final MapIterator iter = avMap.mapIterator();
        while (iter.hasNext())
        {
            final AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            try
            {
                aval.startActivitySet(activitySet);
            }
            catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
        }        
        this.save();

        // create initial issue creation activity
        ActivityManager.createReportIssueActivity(this, activitySet,  
                Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueCreated"));

        // this needs to be done after the issue is created.
        // check to make sure the attachment has data before submitting it.
        final String attachmentData = attachment.getData();
        if (attachmentData != null &&
            attachmentData.length() > 0)
        {
            attachment = AttachmentManager.getReason(attachment, this, user);
            activitySet.setAttachment(attachment);
        }
        activitySet.save();
        
        // need to clear the cache since this is after the 
        // issue is saved. for some reason, things don't
        // show up properly right away.
        ScarabCache.clear();
        
        index();
        
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setAttributeValues(ActivitySet activitySet,
                                          final HashMap newAttVals,
                                          final Attachment attachment,
                                          final ScarabUser user)
        throws TorqueException,ScarabException
    {
        if (!isTemplate())
        {
            final String msg = doCheckAttributeValueWorkflow(newAttVals, user);
            if (msg != null)
            {
                throw new ScarabException(L10NKeySet.ErrorExceptionMessage,msg); 
            }
        }
        if (attachment != null)
        {
            attachment.setTextFields(user, this, 
                                     Attachment.MODIFICATION__PK);
            attachment.save();
        }
        activitySet = attachActivitySet(activitySet, user, attachment );
        
        final LinkedMap avMap = getModuleAttributeValuesMap(true); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            final String newAttValValue = newAttVal.getValue();

            if (oldAttVal != null &&
            		(newAttValValue != null && !newAttValValue.equals(oldAttVal.getValue())
            		 || newAttValValue == null)
            		 )
            {
                if (newAttValValue != null && newAttValValue.length() > 0)
                {
                    oldAttVal.setProperties(newAttVal);
                }
                else
                {
                    oldAttVal.setDeleted(true);
                }
                oldAttVal.startActivitySet(activitySet);
                oldAttVal.save();
            }
        }
        index();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
       ActivitySet activitySet,
       final ScarabUser user,
       final Attachment attachment,
       final Integer activitySetType 
    )
       throws TorqueException,ScarabException
    {
        if (activitySet == null)
        {
            activitySet = getActivitySet(
               user, attachment,
               activitySetType);
            activitySet.save();
            ScarabCache.clear();
        }

        setLastTransId(activitySet.getActivitySetId());
        save();
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
        ActivitySet activitySet,
        final ScarabUser user,
        final Attachment attachment
    )
        throws TorqueException,ScarabException
    {
        return attachActivitySet(activitySet, user, attachment, ActivitySetTypePeer.EDIT_ISSUE__PK);
    }
              
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
        ActivitySet activitySet,
        final ScarabUser user
    )
        throws TorqueException,ScarabException
    {
        return attachActivitySet(activitySet, user, null, ActivitySetTypePeer.EDIT_ISSUE__PK);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public String doCheckInitialAttributeValueWorkflow(final HashMap newValues, 
                                                       final ScarabUser user)
        throws TorqueException, ScarabException
    {
        String msg = null;
        final Iterator iter = newValues.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            if (attr.isOptionAttribute())
            {
                final AttributeOption toOption = AttributeOptionManager
                     .getInstance(new Integer((String)newValues.get(attrId)));
                msg = WorkflowFactory.getInstance().checkInitialTransition(
                                                    toOption, this, 
                                                    newValues, user);
            }
            if (msg != null)
            {
                break;
            }
        }
        return msg;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public String doCheckAttributeValueWorkflow(final HashMap newAttVals, 
                                                final ScarabUser user)
        throws TorqueException,ScarabException
    {
    	final LinkedMap avMap = getModuleAttributeValuesMap(); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        String msg = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            AttributeOption fromOption = null;
            AttributeOption toOption = null;

            if (newAttVal.getValue() != null)
            {
                if (newAttVal.getAttribute().isOptionAttribute())
                {
                    if (oldAttVal.getOptionId() == null)
                    {
                        fromOption = AttributeOptionManager.getInstance(ScarabConstants.INTEGER_0);
                    }
                    else
                    {
                        fromOption = oldAttVal.getAttributeOption();
                    }
                    toOption = newAttVal.getAttributeOption();
                    msg = WorkflowFactory.getInstance().checkTransition(
                                                        fromOption, 
                                                        toOption, this, 
                                                        newAttVals, user);
                }
                if (msg != null)
                {
                    break;
                }
            }
        }
        return msg;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doEditComment(ActivitySet activitySet, 
            final String newComment, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldComment = attachment.getData();
        if (!newComment.equals(oldComment)) 
        {
            attachment.setData(newComment);
            attachment.save();
           
            activitySet = attachActivitySet( activitySet, user);
            // Save activity record
            ActivityManager
                .createTextActivity(this, null, activitySet,
                                    ActivityType.COMMENT_CHANGED, null, attachment,
                                    oldComment, newComment);
             
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.COMMENT_CHANGED, activitySet,
                    this, user);            
        }
        index();

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doDeleteUrl(ActivitySet activitySet, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldUrl = attachment.getData();
        attachment.setDeleted(true);
        attachment.save();

        activitySet = attachActivitySet( activitySet, user);

        // Save activity record
        ActivityManager
            .createTextActivity(this, null, activitySet,
                                ActivityType.URL_DELETED, null, attachment, oldUrl, null);
        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doRemoveAttachment(ActivitySet activitySet,
                                          final MutableBoolean physicallyDeleted,
                                          final Attachment attachment, 
                                          final ScarabUser user)
        throws TorqueException, ScarabException
    {
        boolean attachmentPhysicallyDeleted = false;
        final boolean physicalDeletionAllowed = Turbine.getConfiguration()
        .getBoolean("scarab.attachment.remove.permanent",false);

        if(physicalDeletionAllowed)
        {
            attachmentPhysicallyDeleted = attachment.deletePhysicalAttachment();
            physicallyDeleted.set(attachmentPhysicallyDeleted);
        }

        attachment.setDeleted(true);
        attachment.save();

        activitySet = attachActivitySet(activitySet, user);
        
        // Save activity record
        ActivityManager
            .createTextActivity(this, null, activitySet,
                    ActivityType.ATTACHMENT_REMOVED, null, attachment, attachment.getFileName(), null);

        return activitySet;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public HashSet getAssociatedUsers() throws TorqueException
    {
        HashSet users = null;
        final Object obj = ScarabCache.get(this, GET_ASSOCIATED_USERS); 
        if (obj == null) 
        {        
            final List attributeList = getModule()
                .getUserAttributes(getIssueType(), true);
            final List attributeIdList = new ArrayList();
            
            for (int i=0; i<attributeList.size(); i++) 
            {
                final Attribute att = (Attribute) attributeList.get(i);
                final RModuleAttribute modAttr = getModule().
                    getRModuleAttribute(att, getIssueType());
                if (modAttr.getActive())
                {
                    attributeIdList.add(att.getAttributeId());
                }
            }
            
            if (!attributeIdList.isEmpty())
            {
                users = new HashSet();
                final Criteria crit = new Criteria()
                    .addIn(AttributeValuePeer.ATTRIBUTE_ID, attributeIdList)
                    .add(AttributeValuePeer.DELETED, false);
                crit.setDistinct();
                
                final List attValues = getAttributeValues(crit);
                for (int i=0; i<attValues.size(); i++) 
                {
                    final List item = new ArrayList(2);
                    final AttributeValue attVal = (AttributeValue) attValues.get(i);
                    final ScarabUser su = ScarabUserManager.getInstance(attVal.getUserId());
                    final Attribute attr = AttributeManager.getInstance(attVal.getAttributeId());
                    item.add(attr);
                    item.add(su);
                    users.add(item);
                }
            }
            ScarabCache.put(users, this, GET_ASSOCIATED_USERS);
        }
        else 
        {
            users = (HashSet)obj;
        }
        return users;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlockingConditionTrue() throws TorqueException
    {
       boolean isBlockingConditionTrue = false;
       final List blockingConditions = this.getRModuleIssueType().getConditions();
       for (Iterator it = blockingConditions.iterator(); !isBlockingConditionTrue && it.hasNext(); )
       {
           final Condition cond = (Condition)it.next();
           isBlockingConditionTrue = cond.evaluate(null, this);
           // Will exit as soon as any evaluates true!
       }
       return isBlockingConditionTrue;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlockingAnyIssue() throws TorqueException
    {
       return this.getBlockedIssues().size() > 0; 
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlocked() throws TorqueException
    {
        return (getBlockingIssues().size()>0);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlockedBy(final String blockingId) throws TorqueException
    {
        final List blockingIssues = getBlockingIssues();
        int issueCount = getBlockingIssues().size();
        if (issueCount==0)
        {
            return false;
        }
        
        for(int index = 0; index < issueCount; index++)
        {
            final Issue issue = (Issue)blockingIssues.get(index);
            final String id = issue.getUniqueId();
            if(id.equals(blockingId))
            {
                return true;
            }
        }
        return false;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlocking(final String blockedId) throws TorqueException
    {
        final List blockedIssues = getBlockedIssues();
        final int issueCount = blockedIssues.size();
        if (issueCount==0)
        {
            return false;
        }
        
        for(int index = 0; index < issueCount; index++)
        {
            final Issue issue = (Issue)blockedIssues.get(index);
            final String id = issue.getUniqueId();
            if(id.equals(blockedId))
            {
                return true;
            }
        }
        return false;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getBlockingIssues() throws TorqueException
    {
        final List blockingIssues = new ArrayList();
        final List prerequisiteIssues = this.getPrerequisiteIssues();
        for (Iterator it = prerequisiteIssues.iterator(); it.hasNext(); )
        {
            final Issue is = (Issue)it.next();
            if (is.isBlockingConditionTrue())
                blockingIssues.add(is);
        }        
        return blockingIssues;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getPrerequisiteIssues() throws TorqueException
    {
        final List blockingIssues = new ArrayList();
        final List parentIssues = this.getParents();
        for (Iterator it = parentIssues.iterator(); it.hasNext(); )
        {
            final Depend depend = (Depend)it.next();
            if (depend.getDependType().getDependTypeId().equals(DependTypePeer.BLOCKING__PK))
            {
                blockingIssues.add(IssuePeer.retrieveByPK(depend.getObservedId()));
            }
        }        
        return blockingIssues;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getRelatedIssues() throws TorqueException
    {
        return getAssociatedIssues(DependTypePeer.NON_BLOCKING__PK);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getDuplicateIssues() throws TorqueException
    {
        return getAssociatedIssues(DependTypePeer.DUPLICATE__PK);
    }
              
// in java/org/tigris/scarab/om/Issue.java
private List getAssociatedIssues(final Integer dependTypeId) throws TorqueException
    {
        final List relatedIssues = new ArrayList();
        final List allIssues = this.getAllDependencies();
        for (Iterator it = allIssues.iterator(); it.hasNext(); )
        {
            final Depend depend   = (Depend)it.next();
            final DependType type = depend.getDependType();
            final Integer typeId  = type.getDependTypeId();
            if (typeId.equals(dependTypeId))
            {
                //Assume, the dependant issue is the ObservedId in the Depend
                Issue relatedIssue = IssuePeer.retrieveByPK(depend.getObservedId());
                if(relatedIssue.getIssueId().equals(this.getIssueId()))
                {
                    //No, the dependant issue is the ObserverId in the depend.
                    relatedIssue = IssuePeer.retrieveByPK(depend.getObserverId());
                }
                relatedIssues.add(relatedIssue);
            }
        }        
        return relatedIssues;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getBlockedIssues() throws TorqueException
    {
        if (this.isBlockingConditionTrue())
        {
            return this.getDependantIssues();
        }
        else
        {
            return new ArrayList();
        }
    }
              
// in java/org/tigris/scarab/om/Issue.java
public List getDependantIssues() throws TorqueException
    {
        final List dependantIssues = new ArrayList();
        final List childIssues = this.getChildren();
        for (Iterator it = childIssues.iterator(); it.hasNext(); )
        {
            final Depend depend = (Depend)it.next();
            if (depend.getDependType().getDependTypeId().equals(DependTypePeer.BLOCKING__PK))
            {
                dependantIssues.add(IssuePeer.retrieveByPK(depend.getObserverId()));
            }
        }
        return dependantIssues;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public String getIssueNewId() throws TorqueException
    {
        return ActivityPeer.getNewIssueUniqueId(this);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void setCreatedTransId(Long createdTransId) 
        throws TorqueException
    {
        super.setCreatedTransId(createdTransId);
        if(super.getLastTransId()==null)
            super.setLastTransId(createdTransId);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isRequiredAttributeFor(Attribute attribute, ScarabUser user) throws TorqueException, ScarabException
    {
        Module module         = this.getModule();
        IssueType issueType   = this.getIssueType();
        RModuleAttribute rma  = module.getRModuleAttribute(attribute, issueType);

        boolean result = rma.getRequired();
        if(result == false)
        {
            List<Condition> conditions = rma.getConditions();
                
            Iterator<Condition> iter = conditions.iterator();
            while(iter.hasNext())
            {
                Condition condition = iter.next();
                boolean eval = condition.evaluate(user, this);
                result |= eval;
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Attribute getAttribute(String attributeName) throws TorqueException 
    {
        Attribute result = null;
        List<Attribute> attributes = this.getIssueType().getActiveAttributes(getModule());
        Iterator<Attribute> iter = attributes.iterator();
        while(iter.hasNext())
        {
            Attribute attrib = iter.next();
            String attribName = attrib.getName();
            if(attribName.equals(attributeName))
            {
                result = attrib;
                break;
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public SkipFiltering createIssueChecker(String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        return mystate.createIssueChecker(setMarkerFunction, indent);
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isSealed() throws TorqueException
    {        
        return mystate.isSealed();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public boolean isOnHold() throws TorqueException
    {        
        return mystate.isOnHold();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Attribute getMyStatusAttribute() throws TorqueException
    {
        return mystate.getStatusAttribute();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Attribute getMyOnHoldExpirationDate() throws TorqueException
    {
        return mystate.getOnHoldExpirationDate();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Date getOnHoldUntil() throws TorqueException, ParseException
    {
        return mystate.getOnHoldUntil();
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public void setActivityList(List activityList)
        throws TorqueException
    {
        for (Iterator itr = activityList.iterator();itr.hasNext();)
        {
            Activity activity = (Activity) itr.next();
            activity.setActivitySet(this);
            activity.save();
        }
        ScarabCache.put(activityList, this, GET_ACTIVITY_LIST);
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public List getActivityList(Issue issue) throws TorqueException
    {
         List activityList = (List)ActivitySetManager.getMethodResult()
                .get(this, GET_ACTIVITY_LIST, issue );

        if(activityList==null)
        {
            Criteria crit = new Criteria()
                .add(ActivityPeer.TRANSACTION_ID, getActivitySetId())
                .add(ActivityPeer.ISSUE_ID, issue.getIssueId());
            activityList = ActivityPeer.doSelect(crit);

            ActivitySetManager.getMethodResult()
                .put(activityList, this, GET_ACTIVITY_LIST, issue );
        }
        return activityList;  
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public ScarabUser getCreator()
        throws TorqueException
    {
        return getScarabUser();
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public String getActivityReason() throws TorqueException
    {
        Attachment attachment = this.getAttachment();
        return attachment!=null ? attachment.getData() : "";
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public Set getRemovedUsers(Issue changedIssue) throws TorqueException
    {
        Set removedUsers = new HashSet();
        for (Iterator it = getActivityList(changedIssue).iterator(); it.hasNext(); )
        {
            Activity act = (Activity)it.next();
            if(act.getOldUserId() != null && act.getNewUserId() == null)
            {
                ScarabUser removedUser = ScarabUserManager.getInstance(act.getOldUserId());
                removedUsers.add(removedUser);
            }
        }
        return removedUsers;
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public boolean hasTransitionSealed() throws ScarabException, TorqueException 
    {
        boolean result = false;
        String status = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if (status != null)
        {
            String value = Environment.getConfigurationProperty("scarab.common.status.sealed", null);
            if(value != null)
            {
                
                List<Activity> activities = getActivityList();
                if (activities != null)
                {
                    Iterator<Activity> iter = activities.iterator();
                    if (iter != null)
                    {
                        Activity act = null;
                        try
                        {
                            while((act = iter.next()) != null)
                            {
                                ActivityType at = ActivityType.getActivityType(act.getActivityType());
                                if(at == ActivityType.ATTRIBUTE_CHANGED)
                                {
                                    Attribute att = act.getAttribute();
                                    String name = att.getName();
                                    if(name.equals(status))
                                    {
                                       String oldv = act.getOldValue();
                                       String newv = act.getNewValue();
                                       
                                       if(value.equals(oldv) || value.equals(newv))
                                       {
                                           result = true;
                                           break;
                                       }
                                    }
                                }
                            }
                        }
                        catch (NoSuchElementException nsee)
                        {
                            Throwable th = new Throwable("No such element exception occured.(ignore and assume transitionToSealed=false)");
                            th.printStackTrace();
                            result = false;
                        }
                    }
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
protected List getRModuleUserAttributes(Criteria crit)
                throws TorqueException
            {
                return getPrivateRModuleUserAttributes(crit);
            }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasPermission(String perm, Module module)
               throws TorqueException
            {
                return hasPrivatePermission(perm, module);
            }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
protected void deleteRModuleUserAttribute(final RModuleUserAttribute rmua)
                throws TorqueException, TurbineSecurityException
            {
                privateDeleteRModuleUserAttribute(rmua);
            }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private List getPrivateRModuleUserAttributes(Criteria crit)
        throws TorqueException
    {
        return getRModuleUserAttributes(crit);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private boolean hasPrivatePermission(String perm, Module module)
        throws TorqueException
    {
        return hasPermission(perm, module);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private void privateDeleteRModuleUserAttribute(final RModuleUserAttribute rmua)
        throws TorqueException, TurbineSecurityException
    {
        rmua.delete(this);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasPermission(String perm, Module module)
        throws TorqueException
    {
        if (perm.equals(ScarabSecurity.USER__CHANGE_PASSWORD) && isUserAnonymous())
        {
            return false;
        }

        if (module == null || ScarabSecurity.DOMAIN__ADMIN.equals(perm) || ScarabSecurity.DOMAIN__EDIT.equals(perm))
        {
            module = ModuleManager.getInstance(Module.ROOT_ID);
        }

        AccessControlList aclAnonymous = null;
        if (ScarabUserManager.anonymousAccessAllowed())
        {
            aclAnonymous = ScarabUserManager.getAnonymousUser().getACL();
        }
        
        boolean hasPermission = false;

        AccessControlList acl = this.getACL();
        if (acl != null) 
        {
            hasPermission = aclHasPermission(acl, perm, module);
        }                        
        if (!hasPermission && aclAnonymous != null)
        {
            hasPermission = aclHasPermission(aclAnonymous, perm, module);
        }
        
        return hasPermission;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasPermission(String perm, List modules) throws TorqueException
    {
        return internalUser.hasPermission(perm, modules);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getModules() throws TorqueException
    {
        return internalUser.getModules();
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getModules(boolean showDeletedModules)
        throws TorqueException
    {
        return internalUser.getModules(showDeletedModules);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public Module[] getModules(String permission) throws TorqueException
    {
        return internalUser.getModules(permission);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getCopyToModules(Module currentModule) throws TorqueException
    {        
         return internalUser.getCopyToModules(currentModule);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getCopyToModules(Module currentModule, String action) throws TorqueException
    {        
         return internalUser.getCopyToModules(currentModule, action, null);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getCopyToModules(Module currentModule, String action, 
                                 String searchString)
        throws TorqueException
    {        
         return internalUser.getCopyToModules(currentModule, action, searchString);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasAnyRoleIn(Module module)
        throws TorqueException
    {
        return getRoles(module).size() != 0;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private List getRoles(Module module)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_ROLES, module); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.setDistinct();
            crit.add(TurbineUserGroupRolePeer.USER_ID, getUserId());
            crit.add(TurbineUserGroupRolePeer.GROUP_ID, module.getModuleId());
            crit.addJoin(TurbineRolePeer.ROLE_ID, 
                     TurbineUserGroupRolePeer.ROLE_ID);
            result = TurbineRolePeer.doSelect(crit);
            
            ScarabCache.put(result, this, GET_ROLES, module);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void createNewUser()
        throws TorqueException, DataBackendException, EntityExistsException
    {
        // get a unique id for validating the user
        final String uniqueId = RandomStringUtils
                .randomAlphanumeric(UNIQUE_ID_MAX_LEN);
        // add it to the perm table
        setConfirmed(uniqueId);
        TurbineSecurity.addUser (this, getPassword());
        setPasswordExpire();
        
        // add any roles the anonymous user has, if she is enabled.
        if(ScarabUserManager.anonymousAccessAllowed())
        {
            final ScarabUserImpl anonymous = (ScarabUserImpl) ScarabUserManager.getAnonymousUser();
            final List/*<ScarabModule>*/ modules = anonymous.getNonGlobalModules();
            for(Iterator it0 = modules.iterator(); it0.hasNext(); )
            {
                final ScarabModule module = (ScarabModule)it0.next();
                final List/*<Roles>*/ roles = anonymous.getRoles(module);
                for(Iterator it1 = roles.iterator(); it1.hasNext(); )
                {
                    try 
                    {
                        final Role role = (Role) it1.next();
                        TurbineSecurity.grant(this, (Group) module, role);

                        // TODO: Needs to be refactored into the Users system?
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.GET_ACL);
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable) role, module);
                        
                    }catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getEditableModules() throws TorqueException
    {
        return internalUser.getEditableModules();
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getEditableModules(Module currEditModule)
        throws TorqueException
    {
        return internalUser.getEditableModules(currEditModule);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getNonGlobalModules() throws TorqueException
    {
        List modules = new ArrayList();
        for (Iterator it = internalUser.getModules().iterator(); it.hasNext(); )
        {
            Module m = (Module)it.next();
            if (!m.isGlobalModule())
            {
                modules.add(m);
            }
        }
        return modules;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getRModuleUserAttributes(Module module,
                                         IssueType issueType)
        throws TorqueException
    {
        return internalUser.getRModuleUserAttributes(module, issueType);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                        final Attribute attribute,
                                                        final IssueType issueType)
        throws TorqueException, ScarabException
    {
        return internalUser
            .getRModuleUserAttribute(module, attribute, issueType);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setPasswordExpire()
        throws TorqueException
    {
        String expireDays = Turbine.getConfiguration()
            .getString("scarab.login.password.expire", null);
        
        if (expireDays == null || expireDays.trim().length() == 0)
        {
            setPasswordExpire(null);
        }
        else
        {
            Calendar expireDate = Calendar.getInstance();
            expireDate.add(Calendar.DATE, Integer.parseInt(expireDays));
            setPasswordExpire(expireDate);
        }
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setPasswordExpire(Calendar expire)
        throws TorqueException
    {
        Integer userid = getUserId();
        if (userid == null)
        {
            throw new TorqueException("Userid cannot be null"); //EXCEPTION
        }
        UserPreference up = UserPreferenceManager.getInstance(getUserId());
        if (expire == null)
        {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + 10);
            up.setPasswordExpire(cal.getTime());
        }
        else
        {
            up.setPasswordExpire(expire.getTime());
        }
        up.save();
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean isPasswordExpired()
        throws TorqueException
    {
        // Password for anonymous never expires.
        if (isUserAnonymous())
        {
            return false;
        }
        
        final Integer userid = getUserId();
        if (userid == null)
        {
            return false; // throw new ScarabException (L10NKeySet.ExceptionGeneral,"Userid cannot be null"); //EXCEPTION
        }
        final Criteria crit = new Criteria();
        crit.add(UserPreferencePeer.USER_ID, userid);
        final Calendar cal = Calendar.getInstance();
        crit.add(UserPreferencePeer.PASSWORD_EXPIRE, 
                 cal.getTime() , Criteria.LESS_THAN);
        final List result = UserPreferencePeer.doSelect(crit);
        return result.size() == 1 ? true : false;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean isUserAnonymous()
        throws TorqueException
    {
        boolean brdo = false;
        String anonymous = ScarabUserManager.getAnonymousUserName();
        if (ScarabUserManager.anonymousAccessAllowed() &&
            anonymous != null && getUserName().equals(anonymous))
        {
            brdo = true;
        }
        return brdo;
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public int getEnterIssueRedirect()
        throws TorqueException
    {
        return internalUser.getEnterIssueRedirect();
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setEnterIssueRedirect(int templateCode)
        throws TorqueException
    {
        internalUser.setEnterIssueRedirect(templateCode);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public  String getDefaultQueryId(Module module) throws TorqueException
    {
        return internalUser.getDefaultQueryId(module);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setHomePage(String homePage)
        throws TorqueException, ScarabException
    {
        internalUser.setHomePage(homePage);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getMITLists()
        throws TorqueException
    {
        return internalUser.getMITLists();
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasAnySearchableRMITs()
        throws TorqueException, DataSetException    
    {
        return internalUser.hasAnySearchableRMITs();
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getSearchableRMITs(String searchField, String searchString, 
                                   String sortColumn, String sortPolarity,
                                   Module skipModule)
        throws TorqueException    
    {
        return internalUser.getSearchableRMITs(searchField, searchString, 
            sortColumn, sortPolarity, skipModule);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getUnusedRModuleIssueTypes(Module module)
        throws TorqueException
    {
        return internalUser.getUnusedRModuleIssueTypes(module);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getAllRModuleIssueTypes(Module module)
        throws TorqueException
    {
        return internalUser.getAllRModuleIssueTypes(module);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void addRMITsToCurrentMITList(List rmits)
        throws TorqueException
    {
        internalUser.addRMITsToCurrentMITList(rmits);
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public RModuleIssueType getCurrentRModuleIssueType()
        throws TorqueException
    {
        return internalUser.getCurrentRModuleIssueType();
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void updateIssueListAttributes(List attributes)
        throws TorqueException
    {
        internalUser.updateIssueListAttributes(attributes);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public boolean hasPermission(String perm, List modules) throws TorqueException
    {
        boolean hasPerm = false;
        if (modules != null && !modules.isEmpty()) 
        {
            hasPerm = true;
            Iterator i = modules.iterator();
            while (i.hasNext() && hasPerm) 
            {
                hasPerm = hasPermission(perm, (Module)i.next());
            }
        }
        return hasPerm;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getEditableModules()
        throws TorqueException
    {
        return getEditableModules(null);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getCopyToModules(Module currentModule, String action, 
                                 String searchString)
        throws TorqueException
    {
        List copyToModules = new ArrayList();
        if (hasPermission(ScarabSecurity.ISSUE__MOVE, currentModule) 
            || "copy".equals(action))
        {
            Module[] userModules = getModules(ScarabSecurity.ISSUE__ENTER);
            for (int i=0; i<userModules.length; i++)
            {
                Module module = userModules[i];
                if (!module.isGlobalModule() && 
                    (searchString == null || searchString.equals("") || 
                     module.getName().indexOf(searchString) != -1))
                {
                    copyToModules.add(module);
                }
            }
        }
        else if (hasPermission(ScarabSecurity.ISSUE__EDIT, currentModule)
                 && currentModule.getIssueTypes().size() > 1)
        {
            copyToModules.add(currentModule);
        }
        return copyToModules;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getCopyToModules(Module currentModule)
        throws TorqueException
    {
        return getCopyToModules(currentModule, "copy", null);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getCopyToModules(Module currentModule, String action)
        throws TorqueException
    {
        return getCopyToModules(currentModule, action, null);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getEditableModules(Module currEditModule)
        throws TorqueException
    {
        List userModules = getModules(true);
        List editModules = new ArrayList();

        if (currEditModule != null && currEditModule.getParent().getModuleId().intValue() != 0)
        {
            editModules.add(currEditModule.getParent());
        }
        for (int i=0; i<userModules.size(); i++)
        {
            Module module = (Module)userModules.get(i);
            Module parent = module.getParent();

            if (!editModules.contains(module) && parent != currEditModule)
            {
                if (hasPermission(ScarabSecurity.MODULE__EDIT, module) && module.getModuleId().intValue() != 0)
                {
                    editModules.add(module);
                }
            }
        }
        // we want to remove the module we are editing
        if (currEditModule != null && editModules.contains(currEditModule))
        {
            editModules.remove(currEditModule);
        }

        return editModules;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getRModuleUserAttributes(Module module,
                                         IssueType issueType)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_R_MODULE_USERATTRIBUTES, 
                                     module, issueType); 
        if (obj == null) 
        {
            Integer moduleId    = module.getModuleId();
            Integer userId      = getUserId();
            Integer issueTypeId = issueType.getIssueTypeId();
            Criteria crit = new Criteria()
                .add(RModuleUserAttributePeer.USER_ID,       userId)
                .add(RModuleUserAttributePeer.MODULE_ID,     moduleId)
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, issueTypeId)
                .addAscendingOrderByColumn(RModuleUserAttributePeer.PREFERRED_ORDER);
            
            result = getRModuleUserAttributes(crit);
            ScarabCache.put(result, this, GET_R_MODULE_USERATTRIBUTES,  
                            module, issueType);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                       final Attribute attribute,
                                                       final IssueType issueType)
        throws TorqueException, ScarabException
    {
        RModuleUserAttribute result = null;
        final Object obj = ScarabCache.get(this, GET_R_MODULE_USERATTRIBUTE, 
                                     module, attribute, issueType); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria(4)
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId())
                .add(RModuleUserAttributePeer.LIST_ID, null);
            if (module == null) 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, 
                         module.getModuleId());
                
            }            
            if (issueType == null) 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                         issueType.getIssueTypeId());                
            }
            
            final List muas = RModuleUserAttributePeer.doSelect(crit);
            if (muas.size() == 1) 
            {
                result = (RModuleUserAttribute)muas.get(0);
            }
            else if (muas.isEmpty())
            {
                result = 
                    getNewRModuleUserAttribute(attribute, module, issueType);
            }
            else 
            {
                throw new ScarabException(L10NKeySet.ExceptionMultipleJDMs);
            }
            ScarabCache.put(result, this, GET_R_MODULE_USERATTRIBUTE, 
                            module, attribute, issueType);
        }
        else 
        {
            result = (RModuleUserAttribute)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
protected RModuleUserAttribute getNewRModuleUserAttribute(
        Attribute attribute, Module module, IssueType issueType)
        throws TorqueException
    {
        RModuleUserAttribute result = RModuleUserAttributeManager.getInstance();
        result.setUserId(getUserId());
        result.setAttributeId(attribute.getAttributeId());
        if (module != null) 
        {
            result.setModuleId(module.getModuleId());
        }
        if (issueType != null) 
        {
            result.setIssueTypeId(issueType.getIssueTypeId());
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public int getEnterIssueRedirect()
        throws TorqueException
    {
        if (enterIssueRedirect == 0)
        {
            UserPreference up = UserPreferenceManager.getInstance(getUserId());
            if (up != null && up.getEnterIssueRedirect() != 0)
            {
                enterIssueRedirect = up.getEnterIssueRedirect();
            }
        } 
        return enterIssueRedirect;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void setEnterIssueRedirect(int templateCode)
        throws TorqueException
    {
        UserPreference up = UserPreferenceManager.getInstance(getUserId());
        up.setEnterIssueRedirect(templateCode);
        up.save();
        enterIssueRedirect = templateCode;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public  String getDefaultQueryId(Module module) throws TorqueException
    {
        String homePage = getHomePage(module);
        String result;
        if(homePage.equals("IssueList.vm"))
        {
            Query q = QueryPeer.getDefaultQuery(module, this.getUserId());
            if(q != null)
            {
                homePage="IssueList.vm";
                long cnt = (q.getQueryId());
                return Long.toString(cnt);
            }
        }
        return "";
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
private boolean isHomePageValid(String homePage, Module module) throws TorqueException
    {
        boolean result = true;
        String perm = ScarabSecurity
            .getScreenPermission(homePage.replace(',','.'));
        if (perm != null && !hasPermission(perm, module)) 
        {
            result = false;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void setHomePage(final String homePage)
        throws TorqueException, ScarabException
    {
        if ("ModuleNotReady.vm".equals(homePage)) 
        {
            throw new ScarabException(L10NKeySet.ExceptionForbiddenHomeModuleNotReady);
        }
        final UserPreference up = UserPreferenceManager.getInstance(getUserId());
        up.setHomePage(homePage);
        up.save();
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getMITLists()
        throws TorqueException    
    {
        List result = null;

        Criteria crit = new Criteria();
        crit.add(MITListPeer.ACTIVE, true);
        Criteria.Criterion userCrit = crit.getNewCriterion(
            MITListPeer.USER_ID, getUserId(), Criteria.EQUAL);
        //userCrit.or(crit.getNewCriterion(
           // MITListPeer.USER_ID, null, Criteria.EQUAL));
        crit.add(userCrit);
        crit.add(MITListPeer.MODIFIABLE, true);
        crit.add(MITListPeer.ACTIVE, true);
        crit.add(MITListPeer.NAME, (Object)null, Criteria.NOT_EQUAL);
        crit.addAscendingOrderByColumn(MITListPeer.NAME);
        result = MITListPeer.doSelect(crit);

        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public boolean hasAnySearchableRMITs()
        throws TorqueException, DataSetException    
    {
        boolean result = false;
        final List moduleIds = getSearchableModuleIds();
        if (!moduleIds.isEmpty()) 
        {
            final Criteria crit = new Criteria();
            crit.addIn(RModuleIssueTypePeer.MODULE_ID, moduleIds);
            result = (RModuleIssueTypePeer.count(crit) > 0);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
private List getSearchableModuleIds()
        throws TorqueException    
    {
        Module[] userModules = getModules(ScarabSecurity.ISSUE__SEARCH);
        List moduleIds;
        if (userModules != null && (userModules.length > 1 ||
                userModules.length == 1 && !userModules[0].isGlobalModule())
           ) 
        {
            moduleIds = new ArrayList(userModules.length);
            for (int i=0; i<userModules.length; i++) 
            {
                Module module = userModules[i];
                if (!module.isGlobalModule()) 
                {
                    moduleIds.add(module.getModuleId()); 
                }                
            }
        }
        else 
        {
            moduleIds = Collections.EMPTY_LIST;
        }
        return moduleIds;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getUnusedRModuleIssueTypes(Module module)
        throws TorqueException
    {
        List result;
        if(module == null)
        {
            result = Collections.EMPTY_LIST;
        }
        else
        {
            Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, module.getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.PARENT_ID, 0)
                .add(IssueTypePeer.DELETED, false);
            addCurrentMITListExclusion(crit);
            result = RModuleIssueTypePeer.doSelect(crit);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getAllRModuleIssueTypes(Module module)
        throws TorqueException
    {
        List result;
        if(module == null)
        {
            result = Collections.EMPTY_LIST;
        }
        else
        {
            Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, module.getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.PARENT_ID, 0)
                .add(IssueTypePeer.DELETED, false);
            result = RModuleIssueTypePeer.doSelect(crit);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
private void addCurrentMITListExclusion(Criteria crit)
        throws TorqueException    
    {
            // do not include RMIT's related to current MITListItems.
            MITList mitList = getCurrentMITList(getGenThreadKey());            
            if (mitList != null && mitList.getMITListItems() != null
                && !mitList.getMITListItems().isEmpty()) 
            {
                boolean addAnd = false;
                StringBuffer sb = new StringBuffer();
                Iterator mitItems = 
                    mitList.getExpandedMITListItems().iterator();
                while (mitItems.hasNext()) 
                {
                    MITListItem item = (MITListItem)mitItems.next();
                    if (mitList.getModule(item) != null 
                        && item.getIssueType() != null) 
                    {                  
                        if (addAnd) 
                        {
                            sb.append(" AND ");
                        }
                        
                        sb.append(" NOT (")
                            .append(RModuleIssueTypePeer.MODULE_ID)
                            .append('=')
                            .append(mitList.getModule(item).getModuleId())
                            .append(" AND ")
                            .append(RModuleIssueTypePeer.ISSUE_TYPE_ID)
                            .append('=')
                            .append(item.getIssueType().getIssueTypeId())
                            .append(')');
                        addAnd = true;
                    }
                }   
                // the column name used here is arbitrary (within limits)
                crit.add(IssueTypePeer.ISSUE_TYPE_ID, 
                         (Object)sb.toString(), Criteria.CUSTOM);
            }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getSearchableRMITs(String searchField, String searchString, 
                                   String sortColumn, String sortPolarity,
                                   Module skipModule)
        throws TorqueException    
    {
        List moduleIds = getSearchableModuleIds();
        if (skipModule != null) 
        {
            moduleIds.remove(skipModule.getModuleId());
        }
        
        List result;
        if (moduleIds.isEmpty()) 
        {
            result = Collections.EMPTY_LIST;
        }
        else 
        {
            Criteria crit = new Criteria();
            crit.addIn(RModuleIssueTypePeer.MODULE_ID, moduleIds);
            crit.addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID,
                         IssueTypePeer.ISSUE_TYPE_ID);
            crit.add(IssueTypePeer.PARENT_ID, 0);
            crit.add(IssueTypePeer.DELETED, false);
            addCurrentMITListExclusion(crit);

            // we could add the filter criteria here, but this might
            // result in full table scans.  Even if the table scan turns out
            // to be more efficient, I think it is better to move this
            // into the middle/front tier.
            //addFilterCriteria(crit, searchField, searchString);
            //addSortCriteria(crit, sortColumn, sortPolarity);
            
            result = RModuleIssueTypePeer.doSelect(crit);
            filterRMITList(result, searchField, searchString);
            sortRMITList(result, sortColumn, sortPolarity);
        }
        
        return result;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
protected void filterRMITList(List rmits, 
                                  String searchField, String searchString)
        throws TorqueException
    {
        String moduleName = null;
        String issueTypeName = null;
        if ("issuetype".equals(searchField)) 
        {
            issueTypeName = searchString;
        }
        else 
        {
            moduleName = searchString;
        }
        
        if (moduleName != null && moduleName.length() > 0)
        {
            for (int i=rmits.size()-1; i>=0; i--)
            {
                String name = ((RModuleIssueType)rmits.get(i))
                    .getModule().getRealName();
                if (name == null || name.indexOf(moduleName) == -1)
                {
                    rmits.remove(i);
                }
            }
        }
        if (issueTypeName != null && issueTypeName.length() > 0)
        {
            for (int i=rmits.size()-1; i>=0; i--)
            {
                String name = ((RModuleIssueType)rmits.get(i))
                    .getDisplayName();
                if (name == null || name.indexOf(issueTypeName) == -1)
                {
                    rmits.remove(i);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void addRMITsToCurrentMITList(List rmits)
        throws TorqueException
    {
        if (rmits != null && !rmits.isEmpty()) 
        {
            MITList mitList = getCurrentMITList(getGenThreadKey());
            if (mitList == null) 
            {                
                mitList = MITListManager.getInstance();
                setCurrentMITList(mitList);
            }

            Iterator i = rmits.iterator();
            while (i.hasNext()) 
            {
                RModuleIssueType rmit = (RModuleIssueType)i.next();
                MITListItem item = MITListItemManager.getInstance();
                item.setModuleId(rmit.getModuleId());
                item.setIssueTypeId(rmit.getIssueTypeId());
                if (!mitList.contains(item)) 
                {
                    mitList.addMITListItem(item);        
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public RModuleIssueType getCurrentRModuleIssueType()
        throws TorqueException
    {
        RModuleIssueType rmit = null;
        Module module = getCurrentModule();
        if (module != null) 
        {
            IssueType it = getCurrentIssueType();
            if (it != null) 
            {
                rmit = module.getRModuleIssueType(it);
            }
        }
        
        return rmit;
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void updateIssueListAttributes(List attributes)
        throws TorqueException
    {
        MITList mitList = getCurrentMITList();

        // Delete current attribute selections for user
        for (Iterator currentAttributes = mitList.getSavedRMUAs().iterator();
               currentAttributes.hasNext();) 
        {
            RModuleUserAttribute rmua = (RModuleUserAttribute)currentAttributes.next();
            Criteria crit = new Criteria();
            crit.add(RModuleUserAttributePeer.MODULE_ID, rmua.getModuleId());
            crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, rmua.getIssueTypeId());
            crit.add(RModuleUserAttributePeer.USER_ID, rmua.getUserId());
            crit.add(RModuleUserAttributePeer.LIST_ID, rmua.getListId());
            crit.add(RModuleUserAttributePeer.INTERNAL_ATTRIBUTE, rmua.getInternalAttribute());
            RModuleUserAttributePeer.doDelete(crit);
        }

        int i = 1;
        for (Iterator iter = attributes.iterator(); iter.hasNext();) 
        {
            RModuleUserAttribute rmua = (RModuleUserAttribute)iter.next(); 
            rmua.setOrder(i++);
            rmua.setListId(mitList.getListId());
            if (mitList.isSingleIssueType())
            {
                rmua.setIssueType(mitList.getIssueType());
            }
            if (mitList.isSingleModule())
            {
                rmua.setModule(mitList.getModule());
            }
            rmua.save();
        }
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public void setTextFields(final ScarabUser user, 
            final Issue issue, 
            final Integer typeId) 
        throws TorqueException
    {
        setIssue(issue);
        setTypeId(typeId);
        setMimeType("text/plain");
        //setCreatedDate(new Date());
        setCreatedBy(user.getUserId());
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public void save(Connection dbCon)
        throws TorqueException
    {
        if (getIssue().isNew()) 
        {
            throw new TorqueException("Cannot save an attachment before saving"
                                      + " the issue to which it is attached."); //EXCEPTION
        }
        // It would be better (from an oo perspective) to do this whenever 
        // setData is called, but we can't be sure the typeId will be 
        // set prior to setting the url, so we will do the check here.
        setData(doMakeURLFromData());

        // need to handle the case where we don't want to be smart
        // and just set the dates to be whatever we want them
        // to be (xml import!).
        if (isNew() && (getCreatedDate() == null && getModifiedDate() == null))
        {
            Date now = new Date();
            setCreatedDate(now);
            setModifiedDate(now);
        }
        else if (isModified()) 
        {
            setModifiedDate(new Date());
        }
        
        super.save(dbCon);
        
        try
        {
            FileItem file = getFile();
            if (file != null) 
            {        
                File uploadFile = 
                    new File(getRepositoryDirectory(),getRelativePath());
                File parent = uploadFile.getParentFile();
                if (!parent.exists()) 
                {
                    mkdirs(parent);
                }                
                file.write(uploadFile);
            }
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public boolean deletePhysicalAttachment() 
	throws TorqueException, ScarabException
    {
        File f = new File(getFullPath());
        return f.delete();
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public String getRelativePath()
        throws TorqueException,ScarabException
    {
        if (isNew()) 
        {
            throw new ScarabException(L10NKeySet.ExceptionPathNotSet);
        }        
        String path = null;
        String filename = getFileName();
        if (filename != null) 
        {
            // moduleId/(issue_IdCount/1000)/issueID_attID_filename
            StringBuffer sb = new StringBuffer(30 + filename.length());
            final Issue issue = getIssue();
            sb.append("mod").append(issue.getModule().getQueryKey())
                .append(File.separator)
                .append(issue.getIdCount() / 1000)
                .append(File.separator)
                .append(issue.getUniqueId()).append('_')
                .append(getQueryKey()).append('_')
                .append(filename);
            path = sb.toString();
        }
        return path;
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public String getFullPath()
        throws TorqueException,ScarabException
    {
        String path = null;
        final String relativePath = getRelativePath();
        if (relativePath != null) 
        {
            path = getRepositoryDirectory() + File.separator + relativePath;
        }
        return path;
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public void copyFileTo(final String path)
        throws TorqueException, ScarabException, FileNotFoundException, IOException
    {
        copyFileFromTo(getFullPath(), path);
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public long getSize()
    	throws TorqueException, ScarabException
    {
        if (size== -1) {
        	Log.get(this.getClass().getName()).debug("getSize() reading attachment size from FileSystem");
	        final String path = getFullPath();
	        if (path != null) {
		        final File f = new File(getFullPath());
		        if (f!= null  && f.exists()) {
		            size = f.length();  
	            }
	        }
        } else {
        	Log.get(this.getClass().getName()).debug("getSize() reading attachment size from cache");
        }
        return size;
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public Attachment copy() throws TorqueException
    {
        Attachment copyObj = AttachmentManager.getInstance();
        copyObj.setIssueId(getIssueId());
        copyObj.setTypeId(getTypeId());
        copyObj.setName(getName());
        copyObj.setData(getData());
        copyObj.setFileName(getFileName());
        copyObj.setMimeType(getMimeType());
        copyObj.setModifiedBy(getModifiedBy());
        copyObj.setCreatedBy(getCreatedBy());
        copyObj.setModifiedDate(getModifiedDate());
        copyObj.setCreatedDate(getCreatedDate());
        copyObj.setDeleted(getDeleted());
        return copyObj;
    }
              
// in java/org/tigris/scarab/om/Attachment.java
public Activity getActivity() throws TorqueException
    {
        Activity activity = null;
        Criteria crit = new Criteria()
            .add(ActivityPeer.ATTACHMENT_ID, getAttachmentId());
        
        List activities = ActivityPeer.doSelect(crit);
        if (activities.size() > 0) 
        {
            activity = (Activity)activities.get(0);
        }
        return activity;
     }
              
// in java/org/tigris/scarab/om/ReportPeer.java
public static boolean exists(final String name)
        throws TorqueException, ScarabException
    {
        return retrieveByName(name) != null;
    }
              
// in java/org/tigris/scarab/om/ReportPeer.java
public static Report retrieveByName(final String name)
        throws TorqueException, ScarabException
    {
        Report report = null;
        final Criteria crit = new Criteria()
            .add(NAME, name)
            .add(DELETED, false);
        final List reports = doSelect(crit);
        if (reports.size() == 1) 
        {
            report = (Report)reports.get(0);
        }
        else if (reports.size() > 1) 
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleReports,
                                      name);
        }
        
        return report;
    }
              
// in java/org/tigris/scarab/om/ReportPeer.java
public static Report retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        Report result = null;
        Object obj = ScarabCache.get(REPORT_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseReportPeer.retrieveByPK(pk);
            ScarabCache.put(result, REPORT_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (Report)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/DependManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(DependPeer.DEPEND_ID);
        notifyListeners(listeners, oldOm, om);
        listeners = (List)listenersMap.get(DependPeer.OBSERVER_ID);
        notifyListeners(listeners, oldOm, om);
        listeners = (List)listenersMap.get(DependPeer.OBSERVED_ID);
        notifyListeners(listeners, oldOm, om);
        listeners = (List)listenersMap.get(DependPeer.DEPEND_TYPE_ID);
        notifyListeners(listeners, oldOm, om);
        listeners = (List)listenersMap.get(DependPeer.DELETED);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/RModuleOptionPeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
              
// in java/org/tigris/scarab/om/AttributeType.java
public AttributeClass getAttributeClass()
        throws TorqueException
    {
        AttributeClass result = null;
        Object obj = ScarabCache.get(this, GET_ATTRIBUTE_CLASS);
        if (obj == null) 
        {
            result = super.getAttributeClass();
            ScarabCache.put(result, this, GET_ATTRIBUTE_CLASS);
        }
        else
        {
            result = (AttributeClass)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributeType.java
public static AttributeType getInstance(final String attributeTypeName) 
        throws TorqueException, ScarabException
    {
        AttributeType result = null;
        final Object obj = ScarabCache.get(ATTRIBUTETYPE, GET_INSTANCE, 
                                     attributeTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(AttributeTypePeer.ATTRIBUTE_TYPE_NAME, attributeTypeName);
            final List attributeTypes = AttributeTypePeer.doSelect(crit);
            if(attributeTypes.size() > 1)
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateAttributeTypeName,
                                          attributeTypeName);
            }
            result = (AttributeType)attributeTypes.get(0);
            ScarabCache.put(result, ATTRIBUTETYPE, GET_INSTANCE, 
                            attributeTypeName);
        }
        else 
        {
            result = (AttributeType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/ScarabModulePeer.java
public static List getAllModules()
        throws TorqueException
    {
        return doSelect(new Criteria());
    }
              
// in java/org/tigris/scarab/om/Depend.java
public static Depend getInstance()
        throws TorqueException
    {
        return DependManager.getInstance();
    }
              
// in java/org/tigris/scarab/om/Depend.java
public Attachment getDescriptionAsAttachment(ScarabUser user, Issue issue)
        throws TorqueException
    {
        if (description == null || description.length() == 0)
        {
            return null;
        }
        Attachment comment = AttachmentManager.getInstance();
        comment.setTextFields(user, issue, Attachment.MODIFICATION__PK);
        comment.setData(getDescription());
        comment.setName("modification");
        comment.save();
        return comment;
    }
              
// in java/org/tigris/scarab/om/Depend.java
public void setDependType(String type)
        throws TorqueException
    {
        super.setDependType(DependTypeManager.getInstance(type));
    }
              
// in java/org/tigris/scarab/om/Depend.java
public void setObserverUniqueId(String uniqueId)
         throws TorqueException, ScarabException
    {
        if (getDefaultModule() == null)
        {
            throw new ScarabException( L10NKeySet.ExceptionDependInternalWorkflow,
                                       "setDefaultModule()",
                                       "setObserverUniqueId()");
        }
        Issue childIssue = IssueManager.getIssueById(uniqueId.trim());
        if (childIssue == null)
        {
           String code = getDefaultModule().getCode();
           uniqueId = code + uniqueId;
           childIssue = IssueManager.getIssueById(uniqueId);
        }
        super.setObserverId(childIssue.getIssueId());
    }
              
// in java/org/tigris/scarab/om/Depend.java
public void setProperties(Depend depend)
        throws TorqueException
    {
        this.setObservedId(depend.getObservedId());
        this.setObserverId(depend.getObserverId());
        this.setTypeId(depend.getTypeId());
    }
              
// in java/org/tigris/scarab/om/Depend.java
public void exchangeRoles() throws TorqueException
    {
        Long observerId = getObserverId();
        Long observedId = getObservedId();
        setObserverId(observedId);
        setObservedId(observerId);
    }
              
// in java/org/tigris/scarab/om/RAttributeAttributeGroup.java
public void delete() throws TorqueException 
    { 
        Criteria c = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, getGroupId())
            .add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID, getAttributeId());
            RAttributeAttributeGroupPeer.doDelete(c);
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public boolean canDelete(ScarabUser user)
        throws TorqueException
    {
        // can delete a template if they have delete permission
        // Or if is their personal template
        boolean hasPermission    = user.hasPermission(ScarabSecurity.ITEM__DELETE, getIssue().getModule());
        boolean isCreatedBySelf  = user.getUserId().equals(getIssue().getCreatedBy().getUserId());
        boolean hasScopePersonal = getScopeId().equals(Scope.PERSONAL__PK);
        return (hasPermission || (isCreatedBySelf && hasScopePersonal));
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public boolean canEdit(ScarabUser user)
        throws TorqueException
    {
        return canDelete(user);
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped template, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        boolean success = true;
        final Issue issue = IssueManager.getInstance(getIssueId());

        // If it's a module template, user must have Item | Approve 
        //   permission, or its Approved field gets set to false
        if (getScopeId().equals(Scope.PERSONAL__PK)
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        } 
        else
        {
            setApproved(false);
            issue.save();

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");
                
                ScarabUser[] toUsers = module.getUsers(ScarabSecurity.MODULE__EDIT);
                // if the module doesn't have any users, then we need to add at 
                // least ourselves...
                if (toUsers.length == 0)
                {
                    toUsers = new ScarabUser[1];
                    toUsers[0] = user;
                }

                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewTemplateRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx, 
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null, template);
                }
                catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            }
        }
        save();
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getIssue().getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
              
// in java/org/tigris/scarab/om/RAttributeAttributeGroupManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(RAttributeAttributeGroupPeer.GROUP_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/RModuleIssueTypePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
              
// in java/org/tigris/scarab/om/DependTypeManager.java
public static DependType getInstance(String dependTypeName)
        throws TorqueException
    {
        DependType result = null;
        Object obj = ScarabCache.get(DEPENDTYPE, FIND_DEPENDTYPE_BY_NAME, 
                                     dependTypeName); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(DependTypePeer.DEPEND_TYPE_NAME, dependTypeName);
            List dependTypes = DependTypePeer.doSelect(crit);
            if (dependTypes == null || dependTypes.size() == 0)
            {
                throw new TorqueException("Invalid issue depend type: " + 
                                    dependTypeName); //EXCEPTION
            }
            result = (DependType)dependTypes.get(0);
            ScarabCache.put(result, DEPENDTYPE, FIND_DEPENDTYPE_BY_NAME, 
                            dependTypeName);
        }
        else 
        {
            result = (DependType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/DependTypeManager.java
public static DependType getInstanceById(String dependTypeId)
        throws TorqueException
    {
        DependType result = null;
        List dependTypes = getAll();
        for(int index=0; index < dependTypes.size(); index++)
        {
            DependType entry = (DependType)dependTypes.get(index);
            if(entry.getQueryKey().equals(dependTypeId))
            {
                result = entry;
                break;
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/DependTypeManager.java
public static List getAll()
        throws TorqueException
    {
        return getManager().getAllImpl();
    }
              
// in java/org/tigris/scarab/om/DependTypeManager.java
public List getAllImpl()
        throws TorqueException
    {
        List result = null;
        Object obj = getMethodResult().get(this.toString(), GET_ALL); 
        if (obj == null) 
        {        
            result = DependTypePeer.doSelect(new Criteria());
            getMethodResult().put(result, this.toString(), GET_ALL);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/DependTypeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        getMethodResult().remove(this, GET_ALL);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/DependTypeManager.java
public L10NKey getL10nKey( String dependTypeName ) 
        throws TorqueException 
    {
        return (L10NKey)l10nKeys.get( getInstance(dependTypeName).getDependTypeId());
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void delete(final ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        final IssueType issueType = getIssueType();

        if (user.hasPermission(ScarabSecurity.MODULE__CONFIGURE, module))
        {
            // Delete both active and inactive attribute groups first
            final List attGroups = issueType.getAttributeGroups(module, false);
            for (int j=0; j<attGroups.size(); j++)
            {
                // delete attribute-attribute group map
                final AttributeGroup attGroup = 
                              (AttributeGroup)attGroups.get(j);
                attGroup.delete();
            }

            // Delete mappings with user attributes
            List rmas = module.getRModuleAttributes(issueType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
            // Delete mappings with user attributes for template type
            final IssueType templateType = issueType.getTemplateIssueType();
            rmas = module.getRModuleAttributes(templateType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
 
            // delete workflows
            WorkflowFactory.getInstance().resetAllWorkflowsForIssueType(module, 
                                                                        issueType);
            // delete templates
            Criteria c = new Criteria()
                .add(IssuePeer.TYPE_ID, templateType.getIssueTypeId());
            final List result = IssuePeer.doSelect(c);
            final List issueIdList = new ArrayList(result.size());
            for (int i=0; i < result.size(); i++) 
            {
                final Issue issue = (Issue)result.get(i);
                issueIdList.add(issue.getIssueId());
            }
            IssuePeer.doDelete(c);
            if (!issueIdList.isEmpty())
            {
                c = new Criteria()
                    .addIn(IssueTemplateInfoPeer.ISSUE_ID, issueIdList);
                IssueTemplateInfoPeer.doDelete(c);
            }
            
            // mit list items
            c = new Criteria()
                .add(MITListItemPeer.MODULE_ID, module.getModuleId())
                .add(MITListItemPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
            final List listItems = MITListItemPeer.doSelect(c);
            final List listIds = new ArrayList(listItems.size());

            for (int i=0; i < listItems.size(); i++) 
            {
                final MITList list = ((MITListItem)listItems.get(i)).getMITList();
                final Long listId = list.getListId();
                if (list.isSingleModuleIssueType() && !listIds.contains(listId))
                {
                    listIds.add(listId);
                }
            }
            MITListItemPeer.doDelete(c);

            if (!listIds.isEmpty())
            {
                // delete single module-issuetype mit lists
                c = new Criteria()
                    .addIn(MITListPeer.LIST_ID, listIds);
                MITListPeer.doDelete(c);

                // delete queries
                c = new Criteria()
                    .addIn(QueryPeer.LIST_ID, listIds);
                QueryPeer.doDelete(c);
            }

            c = new Criteria()
                .add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .add(RModuleIssueTypePeer.ISSUE_TYPE_ID, getIssueTypeId());
            RModuleIssueTypePeer.doDelete(c);
            RModuleIssueTypeManager.removeFromCache(this);
            final List rmits = module.getRModuleIssueTypes();
            rmits.remove(this);
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public RModuleIssueType copy()
         throws TorqueException
    {
        RModuleIssueType rmit2 = new RModuleIssueType();
        rmit2.setModuleId(getModuleId());
        rmit2.setIssueTypeId(getIssueTypeId());
        rmit2.setActive(getActive());
        rmit2.setDisplay(getDisplay());
        rmit2.setDisplayDescription(getDisplayDescription());
        rmit2.setOrder(getOrder());
        rmit2.setDedupe(getDedupe());
        rmit2.setHistory(getHistory());
        rmit2.setComments(getComments());
        return rmit2;
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public List<Condition> getConditions(Criteria criteria) throws TorqueException
    {
    	criteria.add(ConditionPeer.ATTRIBUTE_ID, (Object)(ConditionPeer.ATTRIBUTE_ID + " IS NULL"), Criteria.CUSTOM);
    	return super.getConditions(criteria);
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void setConditionsArray(Integer[] aOptionId, Integer operator) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.ATTRIBUTE_ID, null);
        crit.add(ConditionPeer.MODULE_ID, this.getModuleId());
        crit.add(ConditionPeer.ISSUE_TYPE_ID, this.getIssueTypeId());
        crit.add(ConditionPeer.TRANSITION_ID, null);
        ConditionPeer.doDelete(crit);
        this.save();
        this.getConditions().clear();
        ConditionManager.clear();
        if (aOptionId != null)
            for (int i = 0; i < aOptionId.length; i++)
            {
                if (aOptionId[i].intValue() != 0)
                {
                    Condition cond = new Condition();
                    cond.setAttributeId(null);
                    cond.setOptionId(aOptionId[i]);
                    cond.setModuleId(this.getModuleId());
                    cond.setIssueTypeId(this.getIssueTypeId());
                    cond.setTransitionId(null);
                    cond.setOperator(operator);
                    this.addCondition(cond);
                    cond.save();
                }
            }
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public boolean isRequiredIf(Integer optionID) throws TorqueException
    {
        Condition cond = new Condition();
        cond.setAttributeId(null);
        cond.setOptionId(optionID);
        cond.setModuleId(this.getModuleId());
        cond.setIssueTypeId(this.getIssueTypeId());
        cond.setTransitionId(null);
        return this.getConditions().contains(cond);

    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void addCondition(Condition cond) throws TorqueException
    {
        getConditions().add(cond);
        cond.setRModuleIssueType(this);
    }
              
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(RModuleIssueTypePeer.MODULE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
public static void removeFromCache(RModuleIssueType module)
        throws TorqueException
    {
        ObjectKey key = module.getPrimaryKey();
        getManager().removeInstanceImpl(key);
    }
              
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
public static RModuleIssueType getInstance(String key)
        throws TorqueException
    {
        if (key == null) 
        {
            throw new NullPointerException(
                "Cannot request a RModuleIssueType using a null key."); //EXCEPTION
        }
        int colonPos = key.indexOf(':');
        if (colonPos == -1) 
        {
            throw new IllegalArgumentException(
                "RModuleIssueType keys must be of the form N1:N2, not " + key); //EXCEPTION
        }
        // { module_id, issue_type_id } 
        SimpleKey[] keyArray = { new NumberKey(key.substring(1, colonPos)), 
            new NumberKey(key.substring(colonPos+2, key.length()-1)) 
            };
        return getInstance(new ComboKey(keyArray));
    }
              
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes(String attributeType, boolean includeDeleted,
                                     String sortColumn, String sortPolarity)
        throws TorqueException
    {
        Serializable[] cacheKey = {ATTRIBUTE_PEER, GET_ATTRIBUTES, attributeType, Boolean.valueOf(includeDeleted), 
                               sortColumn, sortPolarity};
        List attributes = (List)AttributeManager.getMethodResult().get(cacheKey);
        if(attributes==null)
        {
            Criteria crit = new Criteria();
            crit.add(AttributePeer.ATTRIBUTE_ID, 0, Criteria.NOT_EQUAL);
            if (!includeDeleted)
            {
                crit.add(AttributePeer.DELETED, 0);
            }
            if (attributeType.equals("user"))
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY);
            }
            else
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY, Criteria.NOT_EQUAL);
            }
            if (sortColumn.equals("desc"))
            {
                addSortOrder(crit, AttributePeer.DESCRIPTION, 
                             sortPolarity);
            }
            else if (sortColumn.equals("date"))
            {
                addSortOrder(crit, AttributePeer.CREATED_DATE, 
                             sortPolarity);
            }
            else if (sortColumn.equals("type"))
            {
                crit.addJoin(AttributePeer.ATTRIBUTE_TYPE_ID, 
                             AttributeTypePeer.ATTRIBUTE_TYPE_ID);
                addSortOrder(crit, AttributeTypePeer .ATTRIBUTE_TYPE_NAME, 
                             sortPolarity);
            }
            else if (!sortColumn.equals("user"))
            {
                addSortOrder(crit, AttributePeer.ATTRIBUTE_NAME, 
                             sortPolarity);
            }
            
            attributes = doSelect(crit);

            if (sortColumn.equals("user"))
            {
                attributes = sortAttributesByCreatingUser(attributes, sortPolarity);
            }
            
            AttributeManager.getMethodResult().put(attributes, cacheKey);
        }
        return attributes;
    }
              
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getFilteredAttributes(String name, String description,
                                             String searchField)
        throws TorqueException
    {
        List result = null;
        List allAttributes = getAttributes();
        if (allAttributes == null || allAttributes.size() == 0) 
        {
            result = Collections.EMPTY_LIST;
        }
        else 
        {
            List attrIds = new ArrayList();
            for (int i = 0; i < allAttributes.size(); i++)
            {
                attrIds.add(((Attribute)allAttributes.get(i)).getAttributeId());
            }
            Criteria crit = new Criteria();
            crit.addIn(AttributePeer.ATTRIBUTE_ID, attrIds);
            Criteria.Criterion c = null;
            Criteria.Criterion c1 = null;
            Criteria.Criterion c2 = null;
            
            if (name != null)
            {
                c1 = crit.getNewCriterion(AttributePeer.ATTRIBUTE_NAME,
                         addWildcards(name), Criteria.LIKE);
            }
            if (description != null)
            { 
                c2 = crit.getNewCriterion(AttributePeer.DESCRIPTION,
                         addWildcards(description), Criteria.LIKE);
            }
            if (searchField.equals("Name"))
            {
                c = c1;
            } 
            else if (searchField.equals("Description"))
            {
                c = c2;
            }
            else if (searchField.equals("Any"))
            {
                c = c1.or(c2);
            }
            crit.and(c);
            result = AttributePeer.doSelect(crit);
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes()
        throws TorqueException
    {
        return getAttributes(NON_USER, false, AttributePeer.ATTRIBUTE_NAME, "asc");
    }
              
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes(String attributeType)
        throws TorqueException
    {
        return getAttributes(attributeType, false, AttributePeer.ATTRIBUTE_NAME, 
                             "asc");
    }
              
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes(String attributeType, boolean includeDeleted)
        throws TorqueException
    {
        return getAttributes(attributeType, includeDeleted, AttributePeer.ATTRIBUTE_NAME, 
                             "asc");
    }
              
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes(String sortColumn, 
                                     String sortPolarity)
        throws TorqueException
    {
        return getAttributes(NON_USER, false, sortColumn, sortPolarity);
    }
              
// in java/org/tigris/scarab/om/AttributePeer.java
private static List sortAttributesByCreatingUser(List result,
                                                     String sortPolarity)
        throws TorqueException
    {
        final int polarity = ("asc".equals(sortPolarity)) ? 1 : -1;   
        Comparator c = new Comparator() 
        {
            public int compare(Object o1, Object o2) 
            {
                int i = 0;
                try
                {
                    i = polarity * 
                        ((Attribute)o1).getCreatedUserName()
                         .compareTo(((Attribute)o2).getCreatedUserName());
                }
                catch (Exception e)
                {
                    //
                }
                return i;
             }
        };
        Collections.sort(result, c);
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttributePeer.ATTRIBUTE_ID);
        notifyListeners(listeners, oldOm, om);
        getMethodResult().removeAll(AttributePeer.ATTRIBUTE_PEER, AttributePeer.GET_ATTRIBUTES);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)AttributeValuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
              
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static int countDistinct(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT_DISTINCT);
        return ((Record)AttributeValuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
              
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static Class getOMClass(Record record, int offset) 
        throws TorqueException
    {
        Class c = null;
        try
        {
            Integer attId = new Integer(record.getValue(offset-1 + 3)
                                            .asString());
            Attribute attribute = AttributeManager.getInstance(attId);
            String className = attribute.getAttributeType().getJavaClassName();

            c = (Class)classMap.get(className);
            if (c == null) 
            {
                c = Class.forName(className);
                classMap.put(className, c);            
            }
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        
        return c;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean isGlobal()
        throws TorqueException
    {
        return (getModule() == null);
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if ( id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean hasAnyOptionAttributes()
        throws TorqueException
    {
        boolean result = false;
        for (Iterator i = getAttributes().iterator(); i.hasNext() && !result;) 
        {
            result = ((Attribute)i.next()).isOptionAttribute();
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public List getAttributes()
        throws TorqueException
    {
        List result = null;
        Object obj = getMethodResult().get(this, GET_ATTRIBUTES); 
        if (obj == null) 
        {        
            Log.get().debug("getAttributes() not cached, getting from db");
            Criteria crit = new Criteria()
                .add(RAttributeAttributeGroupPeer.GROUP_ID, 
                     getAttributeGroupId())
                .addJoin(RAttributeAttributeGroupPeer.ATTRIBUTE_ID, 
                         AttributePeer.ATTRIBUTE_ID)
                .add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                     AttributeTypePeer.USER_TYPE_KEY, Criteria.NOT_EQUAL)
                .add(AttributePeer.DELETED, false)
                .addAscendingOrderByColumn(RAttributeAttributeGroupPeer
                                           .PREFERRED_ORDER);
            List raags = RAttributeAttributeGroupPeer.doSelect(crit);
            result = new LinkedList();
            Iterator i = raags.iterator();
            while (i.hasNext()) 
            {
                Integer id = ((RAttributeAttributeGroup)i.next())
                    .getAttributeId();
                result.add(AttributeManager.getInstance(SimpleKey.keyFor(id)));
                if (Log.get().isDebugEnabled()) 
                {
                    Log.get().debug("attribute id=" + id + 
                                    "'s relationship to group was in db");
                }
            }
            getMethodResult().put(result, this, GET_ATTRIBUTES);
        }
        else 
        {
            result = (List)obj;
            if (Log.get().isDebugEnabled()) 
            {
                Log.get().debug("getAttributes() returning cached value");
                for (Iterator i = result.iterator(); i.hasNext();) 
                {
                    Log.get().debug("attribute id=" + 
                                    ((Attribute)i.next()).getAttributeId() + 
                                    "'s relationship to group was in cache");
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean hasAttribute(Attribute attribute)
        throws TorqueException
    {
        List raags = getAttributes();
        return (raags != null && raags.contains(attribute));
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public int getHighestOrderedAttribute ()
        throws TorqueException
    {
        int highest = 0;
        Criteria crit = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, 
                 getAttributeGroupId())
            .addAscendingOrderByColumn(RAttributeAttributeGroupPeer
                                       .PREFERRED_ORDER);
        List raags = RAttributeAttributeGroupPeer.doSelect(crit);
        if (raags.size() > 0)
        {
            RAttributeAttributeGroup raag = (RAttributeAttributeGroup)
                                             raags.get(raags.size()-1);
            highest = raag.getOrder();
        }
        return highest + 1;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public RAttributeAttributeGroup getRAttributeAttributeGroup
        (Attribute attribute)
        throws TorqueException
    {
        RAttributeAttributeGroup result = null;
        Object obj = ScarabCache.get(this, GET_R_ATTRIBUTE_ATTRGROUP, 
                                     attribute); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(RAttributeAttributeGroupPeer.GROUP_ID, 
                     getAttributeGroupId())
                .add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId());
           
            List resultList = RAttributeAttributeGroupPeer.doSelect(crit);
            if(resultList != null && resultList.size() > 0)
            {
                result = (RAttributeAttributeGroup)resultList.get(0);
                ScarabCache.put(result, this, GET_R_ATTRIBUTE_ATTRGROUP, 
                                attribute);
            }
            else
            {
                result = null;
            }
        }
        else 
        {
            result = (RAttributeAttributeGroup)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public List getRModuleAttributes()
        throws TorqueException
    {
        List attrs = getAttributes();
        Iterator i = attrs.iterator();
        List rmas = new ArrayList(attrs.size());
        while (i.hasNext()) 
        {
            Attribute attr = (Attribute)i.next();
            RModuleAttribute rma = getModule().getRModuleAttribute(attr, getIssueType());
            if (rma != null)
            {
                rmas.add(rma);
            }
        }
        return rmas;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public List getRIssueTypeAttributes()
        throws TorqueException
    {
        List attrs = getAttributes();
        Iterator i = attrs.iterator();
        List rias = new ArrayList(attrs.size());
        while (i.hasNext()) 
        {
            Attribute attr = (Attribute)i.next();
            RIssueTypeAttribute ria =
                getIssueType().getRIssueTypeAttribute(attr);
            
            if (ria != null)
            {
                rias.add(ria);
            }
        }
        
        return rias;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void delete()
         throws TorqueException, ScarabException
    {                
        int dupeSequence = 0;
        final Integer issueTypeId = getIssueTypeId();
        final IssueType issueType = IssueTypeManager
            .getInstance(SimpleKey.keyFor(issueTypeId), false);
        List attrGroups = null;

        if (isGlobal())
        {
            attrGroups = issueType.getAttributeGroups(null, false);
            dupeSequence =  issueType.getDedupeSequence();
            // Delete issuetype-attribute mapping
            final Criteria crit  = new Criteria()
                .addJoin(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                         RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                .add(RAttributeAttributeGroupPeer.GROUP_ID,
                     getAttributeGroupId())
                .add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, issueTypeId);
            final List results = RIssueTypeAttributePeer.doSelect(crit);
            for (Iterator i = results.iterator(); i.hasNext();)
            {
                ((RIssueTypeAttribute)i.next()).delete();
            }
        }
        else
        {
            if (issueType.getLocked())
            { 
                
                throw new ScarabException(L10NKeySet.ExceptionGroupDeleteForbidden,
                          this.getName(),
                          issueType.getName());
            }            
            else
            {
                final Module module = getModule();
                attrGroups = getIssueType().getAttributeGroups(module, false);
                dupeSequence =  module.getDedupeSequence(issueType);
                // Delete module-attribute mapping
                final Criteria crit  = new Criteria()
                    .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                             RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                    .add(RAttributeAttributeGroupPeer.GROUP_ID,
                             getAttributeGroupId())
                    .add(RModuleAttributePeer.MODULE_ID,
                         getModuleId());
                final Criteria.Criterion critIssueType = crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                getIssueTypeId(), Criteria.EQUAL);
                critIssueType.or(crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                issueType.getTemplateId(), Criteria.EQUAL));
                crit.and(critIssueType);
                final List results = RModuleAttributePeer.doSelect(crit);
                for (int i=0; i<results.size(); i++)
                {
                    final RModuleAttribute rma = (RModuleAttribute)results.get(i);
                    rma.delete();
                }
            }
        }

        // Delete attribute - attribute group mapping
        Criteria crit2 = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, getAttributeGroupId());
        RAttributeAttributeGroupPeer.doDelete(crit2);


        // Delete the attribute group
        final int order = getOrder();
        crit2 = new Criteria()
            .add(AttributeGroupPeer.ATTRIBUTE_GROUP_ID, getAttributeGroupId());
        AttributeGroupPeer.doDelete(crit2);
        IssueTypeManager.getManager().refreshedObject(this);
            
        // Adjust the orders for the other attribute groups
        for (int i=0; i<attrGroups.size(); i++)
        {
            final AttributeGroup tempGroup = (AttributeGroup)attrGroups.get(i);
            int tempOrder = tempGroup.getOrder();
            if (tempGroup.getOrder() > order)
            {
                if (tempOrder == dupeSequence + 1 && tempOrder == 3)
                {
                    tempGroup.setOrder(tempOrder - 2);
                }
                else
                {
                    tempGroup.setOrder(tempOrder - 1);
                }
                tempGroup.save();
            }
        } 
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void addAttribute(final Attribute attribute)
         throws TorqueException, ScarabException
    {                
        final IssueType issueType = getIssueType();
        final Module module = getModule();

        // add attribute group-attribute mapping
        final RAttributeAttributeGroup raag =
            addRAttributeAttributeGroup(attribute);
        raag.save();
        if (Log.get().isDebugEnabled()) 
        {
            Log.get().debug("Calling getAttributes() from addAttribute in order to add attribute id="
                            + attribute.getAttributeId() + " to the List");
        }
        // FIXME! Distributed cache buster, cache should be invalidated.
        final List attributes = getAttributes();
        if (!attributes.contains(attribute)) 
        {
            attributes.add(attribute);
        }
        
        final List allOptions = attribute.getAttributeOptions(false);
        // remove duplicate options
        // FIXME! why would we ever want Attribute.getAttributeOptions to
        // return dupes, should this code be in that method?
        final ArrayList options = new ArrayList();
        for (int i=0; i<allOptions.size(); i++)
        {
            final AttributeOption option = (AttributeOption)allOptions.get(i);
            if (!options.contains(option))
            {
                options.add(option);
            }
        }

        if (isGlobal())
        {
            // this is a global attribute group
            // add issuetype-attribute groupings
            issueType.addRIssueTypeAttribute(attribute);

            // add issueType-attributeoption mappings
            for (int j=0;j < options.size();j++)
            {
                final AttributeOption option = (AttributeOption)options.get(j);
                final List roos = option.getROptionOptionsRelatedByOption2Id();
                final ROptionOption roo = (ROptionOption)roos.get(0);
                final RIssueTypeOption rio = new RIssueTypeOption();
                rio.setIssueTypeId(issueType.getIssueTypeId());
                rio.setOptionId(option.getOptionId());
                rio.setOrder(roo.getPreferredOrder());
                rio.setWeight(roo.getWeight());
                // making sure error is recorded in same log as our other
                // debugging for pcn 17683.
                try 
                {
                    rio.save();                    
                }
                catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
            }
        }
        else
        {
            // add module-attribute groupings
            module.addRModuleAttribute(issueType, attribute);

            // add module-attributeoption mappings
            for (int j=0;j < options.size();j++)
            {
                final AttributeOption option = (AttributeOption)options.get(j);
                final List roos = option.getROptionOptionsRelatedByOption2Id();
                final ROptionOption roo = (ROptionOption)roos.get(0);
                final RModuleOption rmo = new RModuleOption();
                rmo.setModuleId(getModuleId());
                rmo.setIssueTypeId(issueType.getIssueTypeId());
                rmo.setOptionId(option.getOptionId());
                rmo.setDisplayValue(option.getName());
                rmo.setOrder(roo.getPreferredOrder());
                rmo.setWeight(roo.getWeight());
                rmo.save();

                // add module-attributeoption mappings to template type
                final IssueType templateType = IssueTypeManager
                    .getInstance(issueType.getTemplateId(), false);
                final RModuleOption rmo2 = module.
                     addRModuleOption(templateType, option);
                rmo2.save();
            }
        }
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void deleteAttribute(final Attribute attribute, 
            final ScarabUser user,
            final Module module)
         throws TorqueException, ScarabException
    {                
        String permission = null;
        if (isGlobal())
        {
            permission = (ScarabSecurity.DOMAIN__EDIT);
        }
        else
        {
            permission = (ScarabSecurity.MODULE__CONFIGURE);
        }
        if (user.hasPermission(permission, module))
        {
            final IssueType issueType = getIssueType();
            final IssueType template = IssueTypeManager.getInstance
                                 (issueType.getTemplateId());
            boolean success = true;

            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
            if (isGlobal())
            {
                // This is a global attribute group
                // Remove attribute - issue type mapping
                final List rias = issueType.getRIssueTypeAttributes
                                     (false, AttributePeer.NON_USER);
                if (ria != null) 
                {
                    ria.delete();                    
                }
                if (rias != null) 
                {
                    rias.remove(ria);        
                }
            }
            else
            {
                // Check if attribute is locked
                if (ria != null && ria.getLocked())
                {
                    success = false;
                    throw new TorqueException(attribute.getName() + "is locked"); //EXCEPTION
                }
                else
                {
                    // Remove attribute - module mapping
                    final List rmas = module.getRModuleAttributes(issueType, false,
                                                            AttributePeer.NON_USER);    
                    final RModuleAttribute rma = module
                        .getRModuleAttribute(attribute, issueType);
                    if(rma != null)rma.delete();
                    WorkflowFactory.getInstance().deleteWorkflowsForAttribute
                                                  (attribute, module, issueType);
                    if(rma != null)rmas.remove(rma);

                    // Remove attribute - module mapping from template type
                    final RModuleAttribute rma2 = module
                                   .getRModuleAttribute(attribute, template);
                    if(rma2 != null)
                    {
                        rma2.delete();
                        rmas.remove(rma2);
                    }
                }
            }

            if (success)
            {
                // Remove attribute - group mapping
                final RAttributeAttributeGroup raag = 
                    getRAttributeAttributeGroup(attribute);
                raag.delete();

                if (attribute.isOptionAttribute())
                {
                    if (isGlobal())
                    { 
                        // global attributeGroup; remove issuetype-option maps
                        final List rios = issueType.getRIssueTypeOptions(attribute);
                        if (rios != null)
                        {
                            for (int i = 0; i<rios.size();i++)
                            {
                                ((RIssueTypeOption) rios.get(i))
                                    .delete(user, module);
                            }
                        }
                    }
                    else
                    {
                        // Remove module-option mapping
                        final List rmos = module.getRModuleOptions(attribute, issueType);
                        if (rmos != null)
                        {
                            rmos.addAll(module.getRModuleOptions(attribute, template));
                            for (int j = 0; j<rmos.size();j++)
                            {
                                final RModuleOption rmo = (RModuleOption)rmos.get(j);
                                 // rmo's may be inherited by the parent module.
                                 // don't delete unless they are directly associated
                                 // with this module.  Will know by the first one.
                                 if (rmo.getModuleId().equals(module.getModuleId())) 
                                 {
                                     rmo.delete();
                                 }
                                 else 
                                 {
                                     break;
                                 } 
                             }
                         }
                     }
                 }
             }
         }
         else
         {
             throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
         }            
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
private RAttributeAttributeGroup addRAttributeAttributeGroup(Attribute attribute)
         throws TorqueException
    {                
        RAttributeAttributeGroup raag = new RAttributeAttributeGroup();
        raag.setGroupId(getAttributeGroupId());
        raag.setAttributeId(attribute.getAttributeId());
        if (Log.get().isDebugEnabled()) 
        {
            Log.get().debug("Calling getAttributes() from addRAttributeAttributeGroup "
                            + "in order to determine order for attribute id=" + 
                            attribute.getAttributeId());
        }
        raag.setOrder(getAttributes().size() +1);
        return raag;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public AttributeGroup copyGroup()
         throws TorqueException
    {                
        AttributeGroup newGroup = new AttributeGroup();
        newGroup.setName(getName());
        newGroup.setDescription(getDescription());
        newGroup.setDedupe(getDedupe());
        newGroup.setActive(getActive());
        newGroup.setOrder(getOrder());
        return newGroup;
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean isVisible4User(ScarabUser user) throws TorqueException
    {
        Role role = this.getRole4View();
        boolean bRdo = false;
        if (role == null)
        {
            bRdo = true;
        }
        else
        {
            if (user != null)
            {
                try
                {
	            AccessControlList acl = TurbineSecurity.getACL(user);
	            GroupSet allGroups = TurbineSecurity.getAllGroups();
                    Group group = allGroups.getGroup(user.getCurrentModule().getName());
                    bRdo = acl.hasRole(role, group);
                }
                catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
                catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
            }
        }
        return bRdo;	
    }
              
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getQueries(Module module, IssueType issueType,
                                  ScarabUser user, String sortColumn,   
                                  String sortPolarity, String type)
        throws TorqueException
    {
        List queries = null;
        if (module == null || module.isGlobalModule())
        {
            queries = new ArrayList();
        }
        else 
        {
            Serializable[] key = {QUERY_PEER, GET_QUERIES, module, 
                issueType, user, sortColumn, sortPolarity, type};
            Object obj = QueryManager.getMethodResult().get(key);
            if (obj == null) 
            {

                Criteria crit = new Criteria()
                .add(QueryPeer.DELETED, 0);

                Criteria.Criterion moduleCrit = crit.getNewCriterion(
                        QueryPeer.MODULE_ID, module.getModuleId(), Criteria.EQUAL);
                Criteria.Criterion crossModule = crit.getNewCriterion(
                        QueryPeer.MODULE_ID, null, Criteria.EQUAL);
                moduleCrit.or(crossModule);

                if (issueType != null) 
            {
                Criteria.Criterion issueTypeCrit = crit.getNewCriterion(
                    QueryPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId(), 
                    Criteria.EQUAL);
                Criteria.Criterion nullIssueTypeCrit = crit.getNewCriterion(
                    QueryPeer.ISSUE_TYPE_ID, null, Criteria.EQUAL);
                moduleCrit.and(issueTypeCrit.or(nullIssueTypeCrit));
            }
            



            
            if (TYPE_PRIVATE.equals(type))
            {
                crit.add(userPrivateQueriesCrits(user, crit, moduleCrit));                    
            }
            else if (TYPE_GLOBAL.equals(type))
            {
                crit.add(allGlobalQueriesCrit(crit, moduleCrit));
            }
            else if (TYPE_ALL_USER.equals(type))
            {
                Criteria.Criterion cuGlob = userUnapprovedQueriesCrits(user, crit, moduleCrit);
                Criteria.Criterion cPriv  = userPrivateQueriesCrits(user, crit, moduleCrit);
                cuGlob.or(cPriv);

                Integer moduleOwnerId = module.getOwnerId();
                Integer userId        = user.getUserId();
                if (moduleOwnerId.equals(userId))
                {
                    Criteria.Criterion owner  = ownerQueriesCrit(moduleOwnerId, crit, moduleCrit);
                    cuGlob.or(owner);                    
                }        
                crit.add(cuGlob);
            }
            else
            {
                // All queries
                Criteria.Criterion cGlob  = allGlobalQueriesCrit(crit, moduleCrit);
                Criteria.Criterion cPriv  = userPrivateQueriesCrits(user, crit, moduleCrit);
                cGlob.or(cPriv);
                crit.add(cGlob);
            }

            // Add sort criteria
            if (SORT_DESCRIPTION.equals(sortColumn))
            {
                addSortOrder(crit, QueryPeer.DESCRIPTION, 
                             sortPolarity);
            }
            else if (SORT_AVAILABILITY.equals(sortColumn))
            {
                crit.addJoin(QueryPeer.SCOPE_ID,
                             ScopePeer.SCOPE_ID);
                addSortOrder(crit, ScopePeer.SCOPE_NAME, sortPolarity);
            }
            else if (SORT_USER.equals(sortColumn))
            {
                addSortOrder(crit, QueryPeer.USER_ID, sortPolarity);
            }
            else
            {
                // sort by name
                addSortOrder(crit, QueryPeer.NAME, sortPolarity);
            }
            String tmp = crit.toString();
            queries = QueryPeer.doSelect(crit);
            QueryManager.getMethodResult().put(queries, key);
        }
        else 
        {
            queries = (List)obj;
        }
        }
        return queries;
    }
              
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getUserQueries(ScarabUser user)
        throws TorqueException
    {
        List queries = null;
        Object obj = QueryManager.getMethodResult()
            .get(QUERY_PEER, GET_USER_QUERIES, user);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
                .add(QueryPeer.DELETED, 0);
            crit.add(QueryPeer.USER_ID, user.getUserId());
            queries = QueryPeer.doSelect(crit);
            QueryManager.getMethodResult()
                .put(queries, QUERY_PEER, GET_USER_QUERIES, user);
        }
        else 
        {
            queries = (List)obj;
        }
        return queries;
    }
              
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getModuleQueries(Module module)
        throws TorqueException
    {
        List queries = null;
        Object obj = QueryManager.getMethodResult()
            .get(QUERY_PEER, GET_MODULE_QUERIES, module);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
                .add(QueryPeer.DELETED, 0);
            crit.add(QueryPeer.MODULE_ID, module.getModuleId());
            crit.add(QueryPeer.SCOPE_ID, Scope.MODULE__PK);
            queries = QueryPeer.doSelect(crit);
            QueryManager.getMethodResult()
                .put(queries, QUERY_PEER, GET_MODULE_QUERIES, module);
         }
        else 
        {
            queries = (List)obj;
        }
        return queries;
    }
              
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getQueries(Module module, IssueType issueType,
                                     ScarabUser user)
        throws TorqueException
    {
        return getQueries(module, issueType, user, SORT_AVAILABILITY, "asc", 
                          TYPE_ALL);
    }
              
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getQueries(Module module, IssueType issueType,
                                     ScarabUser user, String sortColumn,   
                                     String sortPolarity)
        throws TorqueException
    {
        return getQueries(module, issueType, user, sortColumn, 
                          sortPolarity, TYPE_ALL);
    }
              
// in java/org/tigris/scarab/om/QueryPeer.java
public static Query getDefaultQuery(Module module) throws TorqueException 
    {
        Integer moduleOwnerId = module.getOwnerId();
        return getDefaultQuery(module, moduleOwnerId);
    }
              
// in java/org/tigris/scarab/om/QueryPeer.java
public static Query getDefaultQuery(Module module, Integer userId) throws TorqueException 
    {
        List<Query> queries = null;
        Object obj = QueryManager.getMethodResult()
            .get(QUERY_PEER, GET_MODULE_QUERIES, module, "homePage");
        if (obj == null) 
        {       
            Integer moduleId      = module.getModuleId();
            Criteria crit = new Criteria()
                .add(QueryPeer.DELETED, 0);
            crit.add(QueryPeer.HOME_PAGE, 1);
            crit.add(QueryPeer.MODULE_ID, moduleId);
            queries = QueryPeer.doSelect(crit);
            QueryManager.getMethodResult()
                .put(queries, QUERY_PEER, GET_MODULE_QUERIES, module, "homePage");
         }
        else 
        {
            queries = (List)obj;
        }
        
        Integer moduleOwnerId = module.getOwnerId();
        Query result = null;
        if(queries != null)
        {
            Iterator<Query> iter = queries.iterator();
            while(iter.hasNext())
            {
                Query candidate = iter.next();
                Integer candidateId = candidate.getUserId();
                Integer scopeId      = candidate.getScopeId();
                boolean isPrivateUserQuery = candidateId.equals(userId) && (scopeId == 1);
                boolean isGlobalQuery      = scopeId == 2;
                if( isPrivateUserQuery || isGlobalQuery )
                {
                    result = candidate; // We found a customized query.
                }
                if(isPrivateUserQuery)
                {
                    break; // It is the user's custom query. Take that and be happy.
                }
            }
            // Now result contains either the user's customized query, 
            // or the module owner's query, if the user hasn't configured one by himself,
            // or null, if no query could be found at all for either the user or the module owner.
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/NotificationStatusManager.java
public static List<NotificationStatus> getNotificationsFor(ScarabUser user) throws TorqueException
    {
        //NotificationStatusManager.getInstance().
        List result = null;
        Criteria crit = new Criteria()
        .add(NotificationStatusPeer.RECEIVER_ID, user.getUserId());
        crit.and(NotificationStatusPeer.STATUS, NotificationStatus.MARK_DELETED, Criteria.NOT_EQUAL);
        result = NotificationStatusPeer.doSelect(crit);
        return result;
    }
              
// in java/org/tigris/scarab/om/NotificationStatusManager.java
public static int getNotificationCount(Module module, ScarabUser user) throws TorqueException
    {
        List<NotificationStatus> notifications = getNotificationsFor(user);
        int count = 0;
        Iterator<NotificationStatus> iter = notifications.iterator();
        int currentModuleId = module.getModuleId();
        while(iter.hasNext())
        {
            NotificationStatus status = iter.next();
            long issueId  = status.getIssueId();
            Issue issue   = IssueManager.getInstance(issueId);
            int moduleId  = issue.getModuleId();
            if(moduleId == currentModuleId)
            {
                count++;
            }
        }
        return count;
    }
              
// in java/org/tigris/scarab/om/ScopePeer.java
public static List getAllScopes()
        throws TorqueException
    {
        return doSelect(new Criteria(0));
    }
              
// in java/org/tigris/scarab/om/ModuleManager.java
public static Module getInstance(String moduleDomain, 
                                     String moduleRealName, 
                                     String moduleCode)
        throws TorqueException
    {
        return getManager().getInstanceImpl(moduleDomain, moduleRealName, 
                                            moduleCode);
    }
              
// in java/org/tigris/scarab/om/ModuleManager.java
protected Module getInstanceImpl(final String moduleDomain, 
                                     final String moduleRealName, 
                                     final String moduleCode)
        throws TorqueException
    {
        final Criteria crit = new Criteria();
        if( moduleDomain != null )
        {
            crit.add(ScarabModulePeer.DOMAIN, moduleDomain);
        }
        if( moduleRealName != null )
        {
            crit.add(ScarabModulePeer.MODULE_NAME, moduleRealName);
        }
        if( moduleCode != null )
        {
            crit.add(ScarabModulePeer.MODULE_CODE, moduleCode);
        }
        final List result = ScarabModulePeer.doSelect(crit);
        if (result.size() != 1)
        {
            throw new TorqueException ("Selected: " + result.size() + 
                " rows. Expected 1."); //EXCEPTION
        }
        return (Module) result.get(0);
    }
              
// in java/org/tigris/scarab/om/ModuleManager.java
public static List getInstancesFromIssueList(List issues)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        

        List modules = new ArrayList();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            if (issue != null)
            {
                Module module = issue.getModule();
                if (module != null && !modules.contains(module)) 
                {
                    modules.add(module);
                }
            }
            else
            {
                throw new TorqueException("Null issue in list is not allowed."); //EXCEPTION
            }
        }
        return modules;
    }
              
// in java/org/tigris/scarab/om/ModuleManager.java
protected Persistent putInstanceImpl(Persistent om)
    throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        getMethodResult().removeAll((ScarabModule)om, ScarabModule.GET_DEFAULTREPORT);
        List listeners = (List)listenersMap.get(ReportPeer.REPORT_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/AttachmentManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttachmentPeer.ISSUE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
              
// in java/org/tigris/scarab/om/AttachmentManager.java
public static Attachment getInstance(String id)
        throws TorqueException
    {
        return getInstance(new Long(id));
    }
              
// in java/org/tigris/scarab/om/AttachmentManager.java
public static Attachment getComment(Attachment attachment, Issue issue, 
                                        ScarabUser user)
         throws TorqueException
    {
        return populate(attachment, issue, Attachment.COMMENT__PK, "comment", 
                 user, "text/plain");
    }
              
// in java/org/tigris/scarab/om/AttachmentManager.java
public static Attachment getReason(Attachment attachment, Issue issue, 
                                        ScarabUser user)
         throws TorqueException
    {
        return populate(attachment, issue, Attachment.MODIFICATION__PK, "reason", 
                 user, "text/plain");
    }
              
// in java/org/tigris/scarab/om/AttachmentManager.java
private static Attachment populate(Attachment attachment,
                                      Issue issue, Integer typeId, 
                                      String name, ScarabUser user, 
                                      String mimetype)
         throws TorqueException
    {
        attachment.setIssue(issue);
        attachment.setTypeId(typeId);
        attachment.setName(name);
        attachment.setCreatedBy(user.getUserId());
        attachment.setMimeType(mimetype);
        attachment.save();
        return attachment;
    }
              
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static IssueType retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        IssueType result = null;
        Object obj = ScarabCache.get(ISSUE_TYPE_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseIssueTypePeer.retrieveByPK(pk);
            ScarabCache.put(result, ISSUE_TYPE_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (IssueType)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static List getAllIssueTypes(boolean deleted,
                       String sortColumn, String sortPolarity)
        throws TorqueException
    {
        List result = null;
        Boolean b = deleted ? Boolean.TRUE : Boolean.FALSE;
        Object obj = ScarabCache.get(ISSUE_TYPE_PEER, GET_ALL_ISSUE_TYPES, b); 
        if (obj == null) 
        {        
            Criteria c = new Criteria();
            c.add(IssueTypePeer.PARENT_ID, 0);
            c.add(IssueTypePeer.ISSUE_TYPE_ID, 0, Criteria.NOT_EQUAL);
            if (deleted)
            {
                c.add(IssueTypePeer.DELETED, 1);
            }
            else
            {
                c.add(IssueTypePeer.DELETED, 0);
            }
            if (sortColumn != null && sortColumn.equals("desc"))
            {
                addSortOrder(c, IssueTypePeer.DESCRIPTION, 
                             sortPolarity);
            }
            else
            {
                // sort on name
                addSortOrder(c, IssueTypePeer.NAME, 
                             sortPolarity);
            }
            result = doSelect(c);
            ScarabCache.put(result, ISSUE_TYPE_PEER, GET_ALL_ISSUE_TYPES, b);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static List getAllIssueTypes(boolean includeDeleted)
        throws TorqueException
    {
        return getAllIssueTypes(includeDeleted, "name", "asc");
    }
              
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static List getDefaultIssueTypes()
        throws TorqueException
    {
        Criteria c = new Criteria();
        c.add(IssueTypePeer.PARENT_ID, 0);
        c.add(IssueTypePeer.DELETED, 0);
        c.add(IssueTypePeer.ISDEFAULT, 1);
        c.add(IssueTypePeer.ISSUE_TYPE_ID, 0, Criteria.NOT_EQUAL);
        return IssueTypePeer.doSelect(c);
    }
              
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static boolean isUnique(String name, Integer id)
        throws TorqueException
    {
        boolean unique = true;
        name = name.trim();
        Criteria crit = new Criteria().add(IssueTypePeer.NAME, name);
        crit.setIgnoreCase(true);
        List types = IssueTypePeer.doSelect(crit);
        if (types.size() > 0) 
        {
            for (int i =0; i<types.size();i++)
            {
                IssueType it = (IssueType)types.get(i);
                if ((id == null ||  
                     (id != null && !it.getIssueTypeId().equals(id)))
                    && it.getName().trim().toLowerCase().equals(name.toLowerCase()))
                {
                    unique = false;
                }
            }
        }
        return unique;
    }
              
// in java/org/tigris/scarab/om/AttachmentType.java
public static AttachmentType getInstance(String attachmentTypeName)
        throws TorqueException,ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(BaseAttachmentTypePeer.ATTACHMENT_TYPE_NAME, attachmentTypeName);
        List attachmentTypes = AttachmentTypePeer.doSelect(crit);
        if(attachmentTypes.size() > 1)
        {
            throw new ScarabException(L10NKeySet.ExceptionAttachmentDuplicateTypename);
        }
        return (AttachmentType)attachmentTypes.get(0);
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getTemplates(Module module, IssueType issueType,
                                    ScarabUser user, String sortColumn, 
                                    String sortPolarity, String type)
        throws TorqueException, ScarabException
    {
        List templates = null;
        Serializable[] key = {TEMPLATE_PEER, GET_TEMPLATES, module,
            issueType, user, sortColumn, sortPolarity, type};
        Object obj = ScarabCache.get(key);
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(IssuePeer.MODULE_ID, module.getModuleId())
                .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MOVED, 0)
                .addJoin(ActivitySetPeer.TRANSACTION_ID, 
                         ActivityPeer.TRANSACTION_ID) 
                .addJoin(IssuePeer.ISSUE_ID, 
                         ActivityPeer.ISSUE_ID) 
                .add(IssuePeer.TYPE_ID, issueType.getTemplateId())
                .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID);
            crit.setDistinct();

            Criteria.Criterion cGlob = crit.getNewCriterion(
                IssueTemplateInfoPeer.SCOPE_ID, Scope.MODULE__PK,
                Criteria.EQUAL);
            cGlob.and(crit.getNewCriterion(IssueTemplateInfoPeer.APPROVED, 
                                           Boolean.TRUE, Criteria.EQUAL));
            Criteria.Criterion cPriv = crit.getNewCriterion(
                ActivitySetPeer.CREATED_BY, user.getUserId(),  
                Criteria.EQUAL);
            cPriv.and(crit.getNewCriterion(
                IssueTemplateInfoPeer.SCOPE_ID, Scope.PERSONAL__PK, 
                Criteria.EQUAL));

            if (TYPE_PRIVATE.equals(type))
            {
                crit.add(cPriv);
            }
            else if (TYPE_GLOBAL.equals(type))
            {
                crit.add(cGlob);
            }
            else
            {
                // All templates
                cGlob.or(cPriv);
                crit.add(cGlob);
            }

            // Add sort criteria
            if (sortColumn.equals("desc"))
            {
                addSortOrder(crit, IssueTemplateInfoPeer.DESCRIPTION, 
                             sortPolarity);
            }
            else if (sortColumn.equals("avail"))
            {
                crit.addJoin(IssueTemplateInfoPeer.SCOPE_ID,
                             ScopePeer.SCOPE_ID);
                addSortOrder(crit, ScopePeer.SCOPE_NAME, sortPolarity);
            }
            else if (!sortColumn.equals("user"))
            {
                // sort by name
                addSortOrder(crit, IssueTemplateInfoPeer.NAME, sortPolarity);
            }
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, key);
        }
        else 
        {
            templates = (List)obj;
        }
        if (sortColumn.equals("user"))
        {
            templates = sortByCreatingUser(templates, sortPolarity);
        }
        return templates;
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getUserTemplates(ScarabUser user, Module module,IssueType issueType)
        throws TorqueException, ScarabException
    {
        List templates = null;
        Object obj = ScarabCache.get(TEMPLATE_PEER, GET_USER_TEMPLATES, user);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
            .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID)
            .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MODULE_ID, module.getModuleId())
            .addJoin(ActivitySetPeer.TRANSACTION_ID, 
                     ActivityPeer.TRANSACTION_ID) 
                .addJoin(IssuePeer.ISSUE_ID, 
                         ActivityPeer.ISSUE_ID) 
            .add(IssuePeer.TYPE_ID, issueType.getTemplateId())
            .add(ActivitySetPeer.CREATED_BY, user.getUserId());
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, TEMPLATE_PEER, GET_USER_TEMPLATES, user);
        }
        else 
        {
            templates = (List)obj;
        }
        return templates;
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getModuleTemplates(Module module)
        throws TorqueException
    {
        List templates = null;
        Object obj = ScarabCache.get(TEMPLATE_PEER, GET_MODULE_TEMPLATES, module);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
            .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID)
            .add(IssuePeer.DELETED, 0)
            .add(IssuePeer.MODULE_ID, module.getModuleId())
            .add(IssueTemplateInfoPeer.SCOPE_ID, Scope.MODULE__PK);
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, TEMPLATE_PEER, GET_USER_TEMPLATES, module);
        }
        else 
        {
            templates = (List)obj;
        }
        return templates;
    }
              
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
private static List sortByCreatingUser(List result,
                                           String sortPolarity)
        throws TorqueException
    {
        final int polarity = ("asc".equals(sortPolarity)) ? 1 : -1;   
        Comparator c = new Comparator() 
        {
            public int compare(Object o1, Object o2) 
            {
                int i = 0;
                try
                {
                    i = polarity * 
                        ((Issue)o1).getCreatedBy().getFirstName()
                         .compareTo(((Issue)o2).getCreatedBy().getFirstName());
                }
                catch (Exception e)
                {
                    //
                }
                return i;
             }
        };
        Collections.sort(result, c);
        return result;
    }
              
// in java/org/tigris/scarab/om/Report.java
public Module getModule() 
        throws TorqueException
    {
        return ModuleManager.getInstance(getModuleId());
    }
              
// in java/org/tigris/scarab/om/Report.java
public void setModule(Module  v) 
        throws TorqueException
    {
        setModuleId(v.getModuleId());
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public List getAncestors()
        throws TorqueException
    {
        List options = new ArrayList();
        addAncestors(options);
        return options;
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
private void addAncestors(List ancestors)
        throws TorqueException
    {
        List parents = getParents();
        for (int i=parents.size()-1; i>=0; i--) 
        {
            AttributeOption parent = (AttributeOption) 
                parents.get(i);
            if (!ancestors.contains(parent)) 
            {
                ancestors.add(parent);    
                parent.addAncestors(ancestors);
            }
        }
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public List getDescendants()
        throws TorqueException
    {
        List options = new ArrayList();
        addDescendants(options);
        return options;
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
private void addDescendants(List descendants)
        throws TorqueException
    {
        List children = getChildren();
        for (int i=children.size()-1; i>=0; i--)
        {
            AttributeOption child = (AttributeOption)
                children.get(i);
            descendants.add(child);
            child.addDescendants(descendants);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public List getChildren()
        throws TorqueException
    {
        if (sortedChildren == null)
        {
            buildChildren();
        }
        return sortedChildren;
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public List getParents()
        throws TorqueException
    {
        List sortedParents = (List)AttributeOptionManager.getMethodResult().get(
            this, AttributeOptionManager.GET_PARENTS
        );
        if ( sortedParents == null )
        {
            sortedParents = buildParents();
            AttributeOptionManager.getMethodResult().put(
                sortedParents, this, AttributeOptionManager.GET_PARENTS
            );
        }
        return sortedParents;
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
private synchronized void buildChildren()
        throws TorqueException
    {
        Criteria crit = new Criteria()
            .add(ROptionOptionPeer.RELATIONSHIP_ID, 
                 OptionRelationship.PARENT_CHILD)
            .add(ROptionOptionPeer.OPTION1_ID,
                 super.getOptionId());

        List relations = ROptionOptionPeer.doSelect(crit);
        sortedChildren = new ArrayList(relations.size());
        for (int i=0; i < relations.size(); i++)
        {
            ROptionOption relation = (ROptionOption)relations.get(i);
            Integer key = relation.getOption2Id();
            if (key != null)
            {
                sortedChildren.add(relation.getOption2Option());
            }
        }
        sortChildren();
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
private synchronized List buildParents()
        throws TorqueException
    {
        Criteria crit = new Criteria()
            .add(ROptionOptionPeer.RELATIONSHIP_ID, 
                 OptionRelationship.PARENT_CHILD)
            .add(ROptionOptionPeer.OPTION2_ID,
                 super.getOptionId());
        List relations = ROptionOptionPeer.doSelect(crit);

        List sortedParents = new ArrayList(relations.size());
        for (int i=0; i < relations.size(); i++)
        {
            ROptionOption relation = (ROptionOption)relations.get(i);
            Integer key = relation.getOption1Id();
            if (key != null)
            {
                sortedParents.add(relation.getOption1Option());
            }
        }
        Collections.sort(sortedParents, getComparator());

        return sortedParents;
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean isChildOf(AttributeOption parent)
        throws TorqueException
    {
        return getParents().contains(parent);
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean isParentOf(AttributeOption child)
        throws TorqueException
    {
        return getChildren().contains(child);
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean hasChildren()
        throws TorqueException
    {
        return getChildren().size() > 0 ? true : false;
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean hasParents()
        throws TorqueException
    {
        return getParents().size() > 0 ? true : false;
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public AttributeOption getParent()
        throws TorqueException
    {
        AttributeOption parent = null;
        List parents = getParents();
        if (parents.size() == 1)
        {
           parent = (AttributeOption) parents.get(0);
        }
        return parent;
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public void deleteModuleMappings()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RModuleOptionPeer.OPTION_ID, getOptionId());
        RModuleOptionPeer.doDelete(crit);
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public void deleteIssueTypeMappings()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
        RIssueTypeOptionPeer.doDelete(crit);
        ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
private List getIssueTypesWithMappings()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
        crit.addJoin(RIssueTypeOptionPeer.ISSUE_TYPE_ID, 
                     IssueTypePeer.ISSUE_TYPE_ID);
        return IssueTypePeer.doSelect(crit);
    }
              
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean isSystemDefined()
        throws TorqueException
    {
        boolean systemDefined = false;
        List issueTypeList = getIssueTypesWithMappings();
        for (Iterator i = issueTypeList.iterator(); 
             i.hasNext() && !systemDefined;)
        {
            systemDefined = ((IssueType)i.next()).isSystemDefined();
        }
        return systemDefined;
    }
              
// in java/org/tigris/scarab/om/UserPreferenceManager.java
public static UserPreference getInstance(Integer userid)
        throws TorqueException
    {
        if (userid == null)
        {
            throw new IllegalArgumentException("User ID cannot be null"); //EXCEPTION
        }

        UserPreference up = null;
        try
        {
            up = BaseUserPreferenceManager.getInstance(userid);
        }
        catch (TorqueException te)
        {
            // Empty result...Failed to select one and only one row.
        }
        if (up == null)
        {
            up = UserPreferenceManager.getInstance();
            up.setUserId(userid);
        }
        return up;
    }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private void logNotificationData(NotificationStatus notification) throws TorqueException
    {
        try
        {
            log.error("queueNotifications():comment:"      + notification.getComment());
            log.error("queueNotifications():changeDate:"   + notification.getChangeDate());
            log.error("queueNotifications():creationDate:" + notification.getCreationDate());
            log.error("queueNotifications():creator:"      + notification.getCreator().toString());
            log.error("queueNotifications():issueId:"      + notification.getIssueId());
            log.error("queueNotifications():primaryKey:"   + notification.getPrimaryKey().toString());
            log.error("queueNotifications():queryKey:"     + notification.getQueryKey());
            log.error("queueNotifications():receiver:"     + notification.getReceiver().toString());
            log.error("queueNotifications():status:"       + notification.getStatusLabel());
        }
        catch(Exception e)
        {
            log.error("queueNotifications(): while dumping notificationData: " + e.getMessage(),e);
        }
    }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private void createWakeupNotification(Issue issue, ScarabUser user, String wakeupMessage) throws TorqueException
    {
        Date date;
        try {
            date = issue.getOnHoldUntil();
        } catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            Activity activity = ActivityManager.getInstance();
            Attribute attribute = issue.getMyStatusAttribute();

            activity.setAttribute(attribute);
            activity.setActivityType(ActivityType.ISSUE_ONHOLD.getCode());
            activity.setDescription("WakeupFromOnHoldstate");
            activity.setIssue(issue);
            activity.setEndDate(date);
            activity.setNewValue("");
            activity.setOldValue("");
            activity.setOldOptionId(0);
            activity.setNewOptionId(0);
            
            Attachment attachment = AttachmentManager.getInstance();
            attachment.setTextFields(user, issue,Attachment.COMMENT__PK);
            attachment.setData(wakeupMessage);
            attachment.setName("comment");
            attachment.save();
            
            activity.setAttachment(attachment);
            
            Integer tt = ActivitySetTypePeer.EDIT_ISSUE__PK;
            ActivitySet activitySet;
            try {
                activitySet = ActivitySetManager.getInstance(tt, user);
                activitySet.addActivity(activity);
                activitySet.save();
                
                addActivityNotification(ActivityType.ISSUE_REMINDER, activitySet, issue, user);                
            } catch (ScarabException e) {
                throw new RuntimeException(e);
            }
    }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private boolean getIsStatusAttribute(Attribute attribute, Issue issue)
    throws TorqueException
    {
        Attribute statusAttribute = issue.getMyStatusAttribute();
        if(statusAttribute == null)
        {
            return false;
        }
        boolean result = statusAttribute.equals(attribute);
        return result;
    }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private String[] getFromUser(Issue issue, EmailContext context) throws TorqueException
    {
        String[] replyToUser = null;
    
        Set creators = (Set)context.get("creators");
        if (creators.size()==1)
        {
            // exactly one contributor to this E-Mail
            boolean exposeSender = Turbine.getConfiguration()
            .getBoolean("scarab.email.replyto.sender",false);

            if(exposeSender)
            {
                ScarabUser creator = (ScarabUser)creators.toArray()[0];
                replyToUser = new String[] { creator.getName(), creator.getEmail() };
            }
        }
        
        if(replyToUser == null)
        {
         replyToUser = issue.getModule().getSystemEmail();
        }
        
        return replyToUser;
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public void setIssue(Issue issue) throws TorqueException
    {
        this.module     = issue.getModule();
        this.issue      = issue;
        this.conditions = null;
        this.rules      = null;
        this.optionIds  = null;
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public boolean isRequiredIf(Integer optionID) throws TorqueException 
    {
        boolean isRequired = getOptionIds().contains(optionID);
        return isRequired;
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public void setConditionsArray(Integer[] optionId, Integer operator) throws TorqueException 
    {
        NotificationRulePeer.saveConditions(user, module, optionId, operator);
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public List<Condition> getConditions() throws TorqueException
    {
        if(conditions == null)
        {
            conditions = NotificationRulePeer.getConditions(user, module);
        }
        return conditions;
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public List<NotificationRule> getRules() throws TorqueException
    {
        if(rules == null)
        {
            NotificationRulePeer.getNotificationRules(user, module);
        }
        return rules;
    }
              
// in java/org/tigris/scarab/notification/Notification.java
private Set<Integer> getOptionIds() throws TorqueException 
    {
        Iterator<Condition> iter = getConditions().iterator();
        Set<Integer>optionIds = new HashSet<Integer>();
        while(iter.hasNext())
        {
            Condition condition = iter.next();
            Integer optionId = condition.getOptionId();
            if(optionId != null)
            {
                optionIds.add(optionId);
            }
        }
        return optionIds;
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public boolean sendConditionsMatch() throws TorqueException 
    {
        List<Condition> conditions = getConditions();
        if(conditions.size() == 0)
        {
            return true; // no conditions defined, hence no constraints, hence return true
        }
        
        Map<String,AttributeValue> attributeValues =  issue.getModuleOptionAttributeValuesMap();
        Integer operator = getConditionOperator();
        
        Iterator<Condition> iter = conditions.iterator();
        Set<Integer>attributeIds = new HashSet<Integer>();

        String forIssueId = "";
        if(this.issue!=null)
        {
            forIssueId = "for issue " + this.issue.getIdPrefix()+ this.issue.getIdCount();
        }
        log.info("test sendNotification conditions "+forIssueId+" -------------");
        
        int matchCounter = 0;
        while(iter.hasNext())
        {
            Condition condition = iter.next();
            AttributeOption ao  = condition.getAttributeOption();
            int optionId = ao.getOptionId();
            Attribute attribute = ao.getAttribute();
            int attributeId = attribute.getAttributeId();
            attributeIds.add(attributeId);
            
            AttributeOption option = AttributeOptionManager.getInstance(optionId);
            
            //log.info("test for " + attribute.getName() + "=\"" + option.getName()    + "\"  (att:" + + attributeId + ",opt:" + optionId+")");
            
            Iterator<Entry<String,AttributeValue>> attvalIterator = attributeValues.entrySet().iterator();
            while( attvalIterator.hasNext())
            {
                Entry<String,AttributeValue> e = attvalIterator.next();
                AttributeValue av = e.getValue();
                int attvalAttributeId = av.getAttributeId();
                Attribute att = av.getAttribute();
                AttributeOption attOpt = av.getAttributeOption();
                if(attributeId == attvalAttributeId)
                {
                    int aoi = av.getOptionId();
                    boolean match = aoi == optionId;
                    //log.info( ((match)? "match ":"      ") + att.getName()       + "=\"" + attOpt.getName()    + "\"  (att:" + attvalAttributeId + ",opt:" + attOpt.getOptionId());
                    if( match)
                    {
                        String sendConditionMet = "SendCondition met. ("+attribute.getName() + "=\"" + option.getName()+")";
                        matchCounter++;
                        if ( operator.equals(OR) )
                        {
                            log.info(sendConditionMet + " -> (send notification)");
                            return true;  // quick exit. first match gives success.
                        }
                        log.info(sendConditionMet);
                        break; // we can break the inner iteration (we found the match)
                    }                    
                }
            }
            
        }

        boolean match; // just in case no condition is defined, we return true
        if(operator.equals(AND) && attributeIds.size() == matchCounter)
        {
            log.info("SendCondition met. (all conditions matched)");
            match = true; // operator 
        }
        else
        {
            if (matchCounter > 0)
            {
                log.info("Only " + matchCounter + " send Conditions out of "+attributeIds.size()+" met. (Send is not triggered.)");
            }
            else
            {
                log.info("None of the " + attributeIds.size() + " available conditions was applicable to this issue. (Send is not triggered.)" );
            }
            match = false;
        }
        
        return match;
    }
              
// in java/org/tigris/scarab/xmlrpc/NewTicketHandler.java
public String createNewTicket( String moduleCode, 
								   String issueTypeName, 
								   String userName, 
								   Hashtable attribs) throws TorqueException, ScarabException {
		
		//init environment for the new issue
		Module module = ModuleManager.getInstance(null, null, moduleCode);
		IssueType issueType = IssueType.getInstance(issueTypeName);
		Issue issue = module.getNewIssue(issueType);
		ScarabUser user = ScarabUserManager.getInstance(userName);
        
        Attachment reason = new Attachment();
        reason.setData("Created by xmlrpc");
        reason.setName("reason");
        
        //init issue, set and store attributes
		ActivitySet activitySet = null;
        activitySet = issue.setInitialAttributeValues(activitySet, reason, new HashMap(), user);

        // Save any unsaved attachments as part of this ActivitySet as well.
        setAttributes(issue,activitySet,reason,user,attribs);
        activitySet = issue.doSaveFileAttachments(activitySet, user);
        activitySet.save();
        
        return issue.getUniqueId();
	}
              
// in java/org/tigris/scarab/xmlrpc/NewTicketHandler.java
private void setAttributes(Issue issue, ActivitySet activitySet, Attachment attachment, ScarabUser user, Hashtable attribs) throws TorqueException, ScarabException {

        LinkedMap avMap = issue.getModuleAttributeValuesMap(false); 
        HashMap newValues = new HashMap();
        
        for (MapIterator i = avMap.mapIterator();i.hasNext();) 
        {
            AttributeValue aval = (AttributeValue)avMap.get(i.next());
        	String key = aval.getAttribute().getName();
        	String newValue = (String)attribs.get(key);
        	
        	if (newValue != null) {
        		AttributeValue newVal = aval.copy();
        		newVal.setValue(newValue);
				newValues.put(aval.getAttributeId(),newVal);
        	}
        }
        issue.setAttributeValues(activitySet, newValues, attachment, user);
	}
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        // find the corresponding attribute
        Attribute attr;
        Criteria crit = new Criteria();
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        List attrList = AttributePeer.doSelect(crit);
        if (attrList.size() == 1) {
            attr = (Attribute) attrList.get(0);
        } else {
            throw new ScarabUpdateException(
                    "Found " + attrList.size() + " attributes for " + attribute + ".");
        }
        return attr;
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getOptionAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        Attribute attr = getAttribute(attribute);
        if (attr.isOptionAttribute()) {
            // do nothing
        } else {
            throw new ScarabUpdateException(
                    "Found non-optiontype attribute when an option type attribte was expected.");
        }
        return attr;
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public List getAttributeOptions(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.add(AttributeOptionPeer.DELETED, false);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                AttributeOptionPeer.ATTRIBUTE_ID);
        return AttributeOptionPeer.doSelect(crit);
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private List getModuleAttributes(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                RModuleAttributePeer.ATTRIBUTE_ID);
        List matOptions = RModuleAttributePeer.doSelect(crit);

        return matOptions;
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private List getIssueTypes(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                RIssueTypeAttributePeer.ATTRIBUTE_ID);
        crit.addJoin(IssueTypePeer.ISSUE_TYPE_ID,
                RIssueTypeAttributePeer.ISSUE_TYPE_ID);
        List itOptions = IssueTypePeer.doSelect(crit);

        return itOptions;
    }
              
// in java/org/tigris/scarab/feeds/IssueFeed.java
public SyndFeed getFeed() throws IOException, FeedException, TorqueException, Exception {

        SyndFeed feed = new SyndFeedImpl();
       
        String title = issue.getUniqueId() + ": " + issue.getDefaultText();
        feed.setTitle(title);
        String link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
        feed.setLink(link);
        feed.setDescription(title);

        List entries = new ArrayList();
        List allActivities = issue.getActivity(true);
        

        for (Iterator i = allActivities.iterator(); i.hasNext();) {
            SyndEntry entry;
            SyndContent description;
            
            Activity activity = (Activity)i.next();
            
            ActivitySet activitySet = activity.getActivitySet();
            Date date =activitySet.getCreatedDate();
            entry = new SyndEntryImpl();

            entry.setPublishedDate(date);
            
            description = new SyndContentImpl();
            description.setType("text/html");
            
            String desc =
                  "<b>Description:</b>" + activity.getDisplayName(this.l10nTool) +"<br/>"
                + "<b>New:</b>" + activity.getNewValue(this.l10nTool) +"<br/>"
                + "<b>Old:</b>" + activity.getOldValue(this.l10nTool) +"<br/>"
                + "<b>Reason:</b>" + activitySet.getCommentForHistory(issue) +"<br/>";
            
            entry.setAuthor(activitySet.getCreator().getName());

            description.setValue(desc.toString());            

			String entryTitle = createEntryTitle(activity);
            entry.setTitle(entryTitle);
            
            entry.setDescription(description);
            
            //The hashCode is a cheap trick to have a unique link tag in the RSS feed
            //to help those reader as ThunderBird that use the link to check for new items
            entry.setLink(link+"?hash="+entry.hashCode());
            
            entries.add(entry);
        }
     

        feed.setEntries(entries);
        
        return feed;
    }
              
// in java/org/tigris/scarab/feeds/QueryFeed.java
public SyndFeed getFeed() throws Exception, TorqueException, DataSetException, TurbineSecurityException
    {
        SyndFeed feed = new SyndFeedImpl();
        feed.setTitle(query.getName());
        String link = scarabLink.setAction("Search").addPathInfo("go",query.getQueryId()).toString();
        feed.setLink(link);
        feed.setDescription(query.getDescription());
        List entries = new ArrayList();
        for(Iterator i = results.iterator(); i.hasNext();)
        {
            SyndEntry entry = new SyndEntryImpl();
            SyndContent description = new SyndContentImpl();
            QueryResult queryResult = (QueryResult)i.next();
            String title = queryResult.getUniqueId();
            entry.setTitle(title);
            
            Issue issue = IssueManager.getInstance(Long.valueOf(queryResult.getIssueId()));

            link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
            entry.setLink(link);

            Date publishedDate = null;
            if(issue.getModifiedDate()!= null){
                publishedDate = issue.getModifiedDate();
            }
            else {
                publishedDate = issue.getCreatedDate();
            }
            entry.setPublishedDate(publishedDate);

            description = new SyndContentImpl();
            description.setType("text/html");
            String desc = "";
            Iterator avIteratorCSV = queryResult.getAttributeValuesAsCSV().iterator();
            Iterator avIterator = query.getMITList().getAllRModuleUserAttributes().iterator();
            while (avIterator.hasNext())
            {
                String value = (String)avIteratorCSV.next();
                RModuleUserAttribute av = (RModuleUserAttribute)avIterator.next();
                desc = desc + "<b>" + av.getAttribute().getName()+":</b>" + value +"<br/>";
            }
            description.setValue(ScarabUtil.filterNonXml(desc));

            entry.setDescription(description);
            entries.add(entry);
        }
        feed.setEntries(entries);
        feed.setFeedType(format);
        return feed;
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doGetissues(RunData data, TemplateContext context) throws TorqueException
    {
        try
        {
            setup(data, context);
        }
        catch(Exception e)
        {
            // no module selected
            return;
        }
        
        ParameterParser pp = data.getParameters();
        Module module = user.getCurrentModule();

        MITList mitList;
        int issueTypeId = pp.getInt("issueType");
        if(issueTypeId > 0)
        {
            // search only within specidied issueType
            IssueType issueType = IssueTypeManager.getInstance(new Integer(issueTypeId));
            mitList = MITListManager.getSingleItemList(module, issueType, user);
        }
        else
        {
            // search all issueTypes in current module
            mitList = MITListManager.getSingleModuleAllIssueTypesList(module, user);            
        }

        user.setCurrentMITList(mitList);
        int optionId    = pp.getInt("option");

        if (optionId > 0)
        {
            // search only issues with given attribute set to given value
            Integer oid = new Integer(optionId);
            AttributeOption ao = AttributeOptionManager.getInstance(oid);
            Integer attId = ao.getAttributeId();
            Attribute attribute = AttributeManager.getInstance(attId);

            AttributeValue av = AttributeValue.getNewInstance(attribute, null);
            String aoname = ao.getName();
            attributeSearch(aoname, av, user);
        }
        else
        {
            // search all issues in current MITList (see MITList initializatoin above)
            processSearch("",  user);
        }

        return;
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
private void addToUsersList(ScarabUser user, MITList list)
        throws TorqueException
    {
        MITList currentList = user.getCurrentMITList();
        if (currentList == null) 
        {
            currentList = MITListManager.getInstance();
            user.setCurrentMITList(currentList);
        }
        
            currentList.addAll(list);
    }
              
// in java/org/tigris/scarab/actions/ModifyModule.java
private void updateModuleParameters(RunData data, Module me) throws TorqueException
    {
        ParameterParser pp = data.getParameters();

        // Update email overrides
        if (GlobalParameterManager.getBoolean(
                GlobalParameter.EMAIL_ALLOW_MODULE_OVERRIDE,me)) 
        {
            String name;
            for (int i=0; i<EMAIL_PARAMS.length; i++) 
            {
                name = EMAIL_PARAMS[i];
                storeGlobalParameterAsBoolean(name, me, pp);
            }
        }

        // update all global module parameters in database
        storeGlobalParameter(GlobalParameter.ISSUE_REASON_REQUIRED, me, pp);
        storeGlobalParameterAsBoolean(GlobalParameter.ISSUE_REASON_HIDDEN, me, pp);
        storeGlobalParameter(GlobalParameter.REQUIRED_ROLE_FOR_REQUESTING_ACCESS, me, pp);
        storeGlobalParameter(GlobalParameter.COMMENT_RENDER_ENGINE, me, pp);
        storeGlobalParameter(GlobalParameter.DEFAULT_REPORT, me, pp);
        
    }
              
// in java/org/tigris/scarab/actions/ModifyModule.java
private void storeGlobalParameterAsBoolean(String name, Module me, ParameterParser pp) throws TorqueException
    {
        boolean storageValue = pp.getBoolean(name);
        GlobalParameterManager
        .setBoolean(name, me, storageValue);
    }
              
// in java/org/tigris/scarab/actions/ModifyModule.java
private void storeGlobalParameter(String name, Module me, ParameterParser pp) throws TorqueException
    {
        String requiredRole = pp.getString(name);
        if (null == requiredRole)
        {
            requiredRole = "";
        }
        GlobalParameterManager.setString(name, me, requiredRole);
    }
              
// in java/org/tigris/scarab/actions/QueryList.java
private boolean setStartpage(List<Query> queries, Query newStartQuery) throws TorqueException
    {
        boolean addedAsStartQuery = false;
        Iterator<Query> iter = queries.iterator();
        while(iter.hasNext())
        {
            Query query = iter.next();
            if (query.getQueryId().equals(newStartQuery.getQueryId()))
            {
                query.setHomePage(true);
                addedAsStartQuery=true;
            }
            else
            {
                query.setHomePage(false);
            }
            query.save();
        }
        return addedAsStartQuery;
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
public void doDelete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        IntakeTool intake = getIntakeTool(context);
        Group attrGroup = intake.get("ConditionEdit", IntakeTool.DEFAULT_KEY);
        data.getParameters().remove(attrGroup.get("ConditionsArray").getKey());
        updateObject(data, context, null);
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void delete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        int nObjectType = data.getParameters().getInt("obj_type");
        Criteria crit = new Criteria();
        switch (nObjectType)
        {
            case ScarabConstants.TRANSITION_OBJECT:
            	Integer tranId = data.getParameters().getInteger("transition_id");
            	crit.add(ConditionPeer.TRANSITION_ID, tranId);
            	TransitionManager.getMethodResult().remove(TransitionManager.getInstance(tranId), TransitionManager.GET_CONDITIONS);
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, 0);
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, 0);
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
        		crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, data.getParameters().getInt("module_id"));
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, data.getParameters().getInt("issueTypeId"));
        		break;
            case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabRequestTool scarabR = getScarabRequestTool(context);
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.deleteConditions(user, module);
                return;
        }
        ConditionPeer.doDelete(crit);
    	ConditionManager.clear();
    	TransitionManager.clear();
    }
              
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
private void modifyInDatabase(NotificationRule rule) throws TorqueException, Exception
    {
        if (equalsDefaultCustomization(rule))
        {
            if (rule.isNew())
            {
                // don't need to create this rule
            }
            else
            {
                // can safely remove this rule
                ObjectKey pk = rule.getPrimaryKey();
                NotificationRulePeer.doDelete(pk);
            }
         }
        else
        {
            // need to store this rule
            rule.save();
        }
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
private int removeUserFromIssue(ScarabUser user, Issue issue) throws TorqueException
    {
        return removeUserFromIssue(user, null, issue);
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
private int removeUserFromIssue(ScarabUser user, Attribute attribute, Issue issue) throws TorqueException
    {
        Set<ArrayList> userSet = issue.getAssociatedUsers();
        return removeUserFromUserSet(user, attribute, userSet);
   }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
private int removeUserFromUserSet(ScarabUser user, Attribute attribute, Set<ArrayList> userSet) throws TorqueException
    {
        Integer userId = user.getUserId();
        Iterator<ArrayList> iter = userSet.iterator();
        Collection toBeRemoved = new ArrayList();

        while(iter.hasNext())
        {
            ArrayList entry = iter.next();
            ScarabUser su = (ScarabUser)entry.get(1);

            if (su.equals(user))
            {
                if(attribute != null)
                {
                    Attribute entryAttribute = (Attribute)entry.get(0);
                    if (!entryAttribute.equals(attribute))
                    {
                        continue;
                    }
                }
                toBeRemoved.add(entry);
            }

        }
        

        userSet.removeAll(toBeRemoved);
        int removeCounter = toBeRemoved.size();
        
        return removeCounter;
   }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
private int addUsersToList(ScarabUser user, Module module, Map userAttributes, StringBuffer msg) throws Exception, TorqueException
    {
        int returnCode;
        Map userMap = user.getAssociatedUsersMap();
        if (userAttributes != null && userAttributes.size() > 0) 
        {
            boolean isUserAttrRemoved = false;
            List removedUserAttrs = null;
            for (Iterator it = userAttributes.keySet().iterator(); it.hasNext(); )
            {
                String userId = (String)it.next();
                List item = new ArrayList();
                String attrId = (String)userAttributes.get(userId);
                Attribute attribute = AttributeManager
                    .getInstance(new Integer(attrId));
                ScarabUser su = ScarabUserManager
                    .getInstance(new Integer(userId));
                item.add(attribute);
                item.add(su);
                List issues = (List)user.getAssignIssuesList();
                for (int j=0; j<issues.size(); j++)
                {
                    Issue issue = (Issue)issues.get(j);
                    Long issueId = issue.getIssueId();
                    Set userList = (Set) userMap.get(issueId);
                    if (userList == null)
                    {
                        userList = new HashSet();
                    }
                    List<Attribute> attributeList = module
                        .getUserAttributes(issue.getIssueType(), true);
                    if (!attributeList.contains(attribute))
                    {
                        if (removedUserAttrs == null)
                        {
                            removedUserAttrs = new ArrayList();
                            removedUserAttrs.add(attribute);
                            msg.append("'").append(attribute.getName())
                                .append("'");
                        }
                        else if (!removedUserAttrs.contains(attribute))
                        {
                            removedUserAttrs.add(attribute);
                            msg.append(", '").append(attribute.getName())
                                .append("'");
                        }
                        isUserAttrRemoved = true;
                    }
                    else
                    {
                        removeUserFromUserSet(su, null, userList); // remove all user entries from set.
                        cleanupMultiAssignEntries(attribute, userList, attributeList);
                        userList.add(item);
                        // userMap.put(issueId, userList);
                        // user.setAssociatedUsersMap(userMap);
                    }
                } 
            }
            if (!isUserAttrRemoved)
            {
                returnCode = USERS_ADDED;
            }
            else 
            {
                returnCode = USERS_REMOVED;
            }
        }
        else
        {
            returnCode = ERR_NO_USERS_SELECTED;
        }
        return returnCode;
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setQueryKey(String key)
        throws TorqueException
    {
        torqueReport.setQueryKey(key);
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setScopeId(Integer id)
        throws TorqueException
    {
        torqueReport.setScopeId(id);
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setUserId(Integer id)
        throws TorqueException
    {
        torqueReport.setUserId(id);
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public Scope getScope()
        throws TorqueException
    {
        return torqueReport.getScope();
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public Module getModule() 
        throws TorqueException
    {
        Module module = null;
        if (torqueReport.getModuleId() != null) 
        {
            module = ModuleManager.getInstance(torqueReport.getModuleId());
        }
        
        return module;
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setModule(Module  v) 
        throws TorqueException
    {
        reportDefn.setModuleIssueTypes(null);
        if (v == null) 
        {
            torqueReport.setModuleId((Integer)null);            
        }
        else 
        {
            torqueReport.setModuleId(v.getModuleId());
            if (torqueReport.getIssueTypeId() != null) 
            {
                ModuleIssueType mit = new ModuleIssueType();
                mit.setModuleId(v.getModuleId());
                mit.setIssueTypeId(torqueReport.getIssueTypeId());
                reportDefn.addModuleIssueType(mit);
            }
        }
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setIssueType(IssueType  v) 
        throws TorqueException
    {
        reportDefn.setModuleIssueTypes(null);
        if (v == null) 
        {
            // issue type id cannot be null
            torqueReport.setIssueTypeId(ScarabConstants.INTEGER_0);
        }
        else 
        {
            torqueReport.setIssueTypeId(v.getIssueTypeId());
            if (torqueReport.getModuleId() != null) 
            {
                ModuleIssueType mit = new ModuleIssueType();
                mit.setModuleId(torqueReport.getModuleId());
                mit.setIssueTypeId(v.getIssueTypeId());
                reportDefn.addModuleIssueType(mit);
            }
        }
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public MITList getMITList()
        throws TorqueException
    {
        MITList mitList = null;
        List mits = reportDefn.getModuleIssueTypes();
        if (mits != null) 
        {
            Log.get().debug("mits were not null");
            mitList = new MITList();
            
            mitList.setScarabUser(this.torqueReport.getScarabUser());
            
            for (Iterator i = mits.iterator(); i.hasNext();) 
            {
                ModuleIssueType mit = (ModuleIssueType)i.next();
                MITListItem item = new MITListItem();
                item.setModuleId(mit.getModuleId());
                item.setIssueTypeId(mit.getIssueTypeId());
                mitList.addMITListItem(item);
            }
        }
        
        return mitList;
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public List filterConditionalTransitions(List transitions, Issue issue) throws TorqueException {
        try {
            boolean blockedIssue = issue.isBlocked();
            if (transitions != null) {
                for (int i=transitions.size()-1; i>=0; i--) {
                    Transition tran = (Transition)transitions.get(i);
                    if (blockedIssue && tran.getDisabledIfBlocked()) {
                        transitions.remove(i);
                        continue;
                        
                    }
                    List conditions = tran.getConditions();
                    if (null != conditions && conditions.size() > 0) {
                        boolean bRemove = true;
                        for (Iterator itReq = conditions.iterator(); bRemove && itReq.hasNext(); ) {
                            Condition cond = (Condition)itReq.next();
                            bRemove = !evaluate(cond, issue);
                        }
                        if (bRemove) {
                            transitions.remove(i);
                        }
                    }
                }
            }
        } catch (Exception e) {
            Log.get().error("filterConditionalTransitions: " + e);
        }
        
        return transitions;
    }
              
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private boolean evaluate(final Condition cond, final Issue issue) throws TorqueException {
        boolean bEval = false;
        Attribute requiredAttribute = cond.getAttributeOption().getAttribute();
        Integer optionId = cond.getOptionId();
        AttributeValue av = issue.getAttributeValue(requiredAttribute);
        if (av != null) {
            Integer issueOptionId = av.getOptionId();
            if (issueOptionId != null && issueOptionId.equals(optionId)) {
                bEval = true;
            }
        }
        return bEval;
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public  SkipFiltering createIssueChecker(String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        String result = "";
        List<Attribute> attributes = null;
        Module module = issue.getModule();
        IssueType issueType = issue.getIssueType();
        attributes = issueType.getActiveAttributes(module);
        Iterator<Attribute> iter = attributes.iterator();
        while (iter.hasNext())
        {
            Attribute attribute = iter.next();
            RModuleAttribute rma  = module.getRModuleAttribute(attribute, issueType);
            result += createIssueChecker(rma, setMarkerFunction, indent);
        }
        
        String prepend;
        if(result.length() > 0)
        {
            prepend="\n";
        }
        else
        {
            prepend = "/* No conditional attributes found for this module/issueType */";
        }
        
        return new SimpleSkipFiltering(prepend+result);
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
private String createIssueChecker(RModuleAttribute rma, String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        String result = "";
        boolean isRequired = rma.getRequired();
        if(!isRequired)
        {
            List<Condition> conditions = rma.getConditions();
                
            Iterator<Condition> iter = conditions.iterator();
            while(iter.hasNext())
            {
                Condition condition = iter.next();
                result += condition.createConditionCheckerScript(rma, setMarkerFunction, indent);
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public boolean isSealed() throws TorqueException
    {        
        boolean result = false;
        String status = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if (status != null)
        {
            String value = Environment.getConfigurationProperty("scarab.common.status.sealed", null);
            if(value != null)
            {
                AttributeValue attval = issue.getAttributeValue(status);
                if(attval != null && attval.getValue().equals(value))
                {
                    result = true;
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public boolean isOnHold() throws TorqueException
    {        
        boolean result = false;
        String status = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if (status != null)
        {
            String value = Environment.getConfigurationProperty("scarab.common.status.onhold", null);
            if(value != null)
            {
                AttributeValue attval = issue.getAttributeValue(status);
                if(attval != null && attval.getValue().equals(value))
                {
                    result = true;
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public boolean isActive() throws TorqueException
    {
        return !(isOnHold() || isSealed());
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public Attribute getStatusAttribute() throws TorqueException
    {
        Attribute attribute = null;
        String attributeName = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if(attributeName != null)
        {
            attribute = issue.getAttribute(attributeName);
        }
        return attribute;
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public Attribute getOnHoldExpirationDate() throws TorqueException
    {
        Attribute attribute = null;
        String attributeName = Environment.getConfigurationProperty("scarab.common.status.onhold.dateProperty", null);
        if(attributeName != null)
        {
            attribute = issue.getAttribute(attributeName);
        }
        return attribute;
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public Date getOnHoldUntil() throws TorqueException, ParseException
    {
        Date date = null;
        String attributeName = Environment.getConfigurationProperty("scarab.common.status.onhold.dateProperty", null);
        
        if (attributeName != null)
        {
            AttributeValue dateValue = issue.getAttributeValue(attributeName);
            if(dateValue!=null) 
            {
                String value = dateValue.getValue();
                if (value != null && value.length() > 0)
                {
                    date = DateAttribute.toDate(value);
                }
            }
        }
        return date;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
void doHandleDependencies()
        throws ScarabException, TorqueException
    {
        LOG.debug("Number of dependencies found: " + allDependencies.size());
        for (Iterator itr = allDependencies.iterator(); itr.hasNext();)
        {
            final Object[] data = (Object[])itr.next();
            final ActivitySet activitySetOM = (ActivitySet) data[0];
            final XmlActivity activity = (XmlActivity) data[1];
            

            final Dependency dependency = activity.getDependency();
            final String child = (String)issueXMLMap.get(dependency.getChild());
            final String parent = (String)issueXMLMap.get(dependency.getParent());
            if (parent == null || child == null)
            {
                if(null != parent || null != child)
                {
                    // add a comment into the issue that informs of the dependency
                    final Issue issueOM = IssueManager.getIssueById(null == parent ? child : parent);
                    final Attachment attachmentOM = new Attachment();
                    attachmentOM.setName("comment");
                    attachmentOM.setTypeId(Attachment.COMMENT__PK);
                    attachmentOM.setMimeType("text/plain");
                    // TODO i18n this
                    final String text = "Dependency \"" 
                            + parent + " (originally " + dependency.getParent() + ") " + dependency.getType() + ' ' 
                            + child + " (originally " + dependency.getParent()
                        + ") \" was not imported due to " 
                        + (null == parent ? dependency.getParent() : dependency.getChild()) + " not being resolved";
                    attachmentOM.setData(text);                    
                    issueOM.addComment(attachmentOM, ScarabUserManager.getInstance("Administrator"));
                }
                
                LOG.debug("Could not find issues: parent: " + parent + " child: " + child);
                LOG.debug("----------------------------------------------------");
                continue;
            }
            LOG.debug("doHandleDependencies: " + dependency);
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                LOG.error("[TODO] update-same-db import type not yet implemented");
                // trick here is that dependencies don't have ids or unique keys to find the 
                //  correct existing instance against.
            }
            else
            {
                try
                {
                    final String type = dependency.getType();
                    final Depend newDependOM = DependManager.getInstance();
                    final Issue parentIssueOM = IssueManager.getIssueById(parent);
                    final Issue childIssueOM = IssueManager.getIssueById(child);
                    newDependOM.setDefaultModule(parentIssueOM.getModule());
                    newDependOM.setObservedId(parentIssueOM.getIssueId());
                    newDependOM.setObserverId(childIssueOM.getIssueId());
                    newDependOM.setDependType(type);
                    LOG.debug("Dep: " + type + " Parent: " + parent + " Child: " + child);
                    LOG.debug("XML Activity id: " + activity.getId());
                    if (activity.isAddDependency())
                    {
                        parentIssueOM
                          .doAddDependency(activitySetOM, newDependOM, childIssueOM, null);
                        LOG.debug("Added Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isDeleteDependency())
                    {
                        parentIssueOM
                          .doDeleteDependency(activitySetOM, newDependOM, null);
                        LOG.debug("Deleted Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isUpdateDependency())
                    {
                        final Depend oldDependOM = parentIssueOM.getDependency(childIssueOM);
                        if (oldDependOM == null)
                        {
                            throw new IllegalArgumentException ("Whoops! Could not find the original dependency!"); //EXCEPTION
                        }
                        // we definitely know we are doing an update here.
                        newDependOM.setDeleted(false);
                        parentIssueOM
                          .doChangeDependencyType(activitySetOM, oldDependOM, newDependOM, null);
                        LOG.debug("Updated Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("Old Type: " + oldDependOM.getDependType().getName() + " New type: " + newDependOM.getDependType().getName());
                        LOG.debug("----------------------------------------------------");
                    }
                }
                catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }                
            }
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueValidateEvent(final XmlModule module, 
            final XmlIssue issue)
        throws TorqueException
    {
        // Check for the existance of the module.
        Module moduleOM = null;
        try
        {
            moduleOM = getModuleForIssue(module,issue);
            if (moduleOM == null)
            {
                throw new IllegalArgumentException(); //EXCEPTION
            }

            // TODO: Handle user import.  Until then, ignore the
            // module's owner.
            //importUsers.add(module.getOwner());
        }
        catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }

        // Check for the existance of the issue type.
        IssueType issueTypeOM = null;
        try
        {
            issueTypeOM = IssueType.getInstance(issue.getArtifactType());
            if (issueTypeOM == null)
            {
                throw new IllegalArgumentException(); //EXCEPTION
            }
            if (!moduleOM.getRModuleIssueType(issueTypeOM).getActive())
            {
                final String error = Localization.format(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueTypeInactive", issue.getArtifactType());
                importErrors.add(error);
            }
            List moduleAttributeList = null;
            if (moduleOM != null)
            {
                moduleAttributeList = moduleOM.getAttributes(issueTypeOM);
            }

            final List activitySets = issue.getActivitySets();
            for (Iterator itr = activitySets.iterator(); itr.hasNext();)
            {
                final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
                if (activitySet.getCreatedBy() != null)
                {
                    importUsers.add(activitySet.getCreatedBy());
                }
                if (activitySet.getAttachment() != null)
                {
                    final String attachCreatedBy = activitySet.getAttachment().getCreatedBy();
                    if (attachCreatedBy != null)
                    {
                        importUsers.add(attachCreatedBy);
                    }
                }

                // Validate the activity set's type.
                try
                {
                    final ActivitySetType ttOM =
                        ActivitySetTypeManager.getInstance(activitySet.getType());
                    if (ttOM == null)
                    {
                        throw new IllegalArgumentException(); //EXCEPTION
                    }
                }
                catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }

                // Validate the activity set's date.
                validateDate(activitySet.getCreatedDate(), true);

                final List activities = activitySet.getActivities();
                for (Iterator itrb = activities.iterator(); itrb.hasNext();)
                {
                    validateActivity(moduleOM, issueTypeOM, moduleAttributeList,
                                     activitySet, (XmlActivity) itrb.next());
                }
            }
        }
        catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Issue createNewIssue(final XmlModule module, final XmlIssue issue, final String id)
        throws TorqueException,ScarabException
    {
        // get the instance of the module
        final Module moduleOM = getModuleForIssue(module,issue);
        // get the instance of the issue type
        final IssueType issueTypeOM = IssueType.getInstance(issue.getArtifactType());
        issueTypeOM.setName(issue.getArtifactType());
        // get me a new issue since we couldn't find one before
        final Issue issueOM = Issue.getNewInstance(moduleOM, issueTypeOM);

        // The import data may nominate its ID
        if (id != null) {
            // This will cause Issue.save() to use this ID
            issueOM.setFederatedId(id);
        }
        // create the issue in the database

        // Add the mapping between the issue id and the id that was created.
        // This mapping is used dependency checking and printing out in 
        // results list of original id and new id. The original issue id can be
        // null. In this case, have the original id show as 'null (index)'
        // where index is count into the issueXMLMap. We add the index to keep
        // the key unique. This substitute original id also shouldn't interfere
        // w/ issueXMLMap's use dependency checking.
        String issueID = "Null (" + Integer.toString(issueXMLMap.size()) + ")";
        if(issue.getId() != null)
        {
            issueID = (issue.hasModuleCode()?"":module.getCode())
                + issue.getId();
        }
        issueXMLMap.put(issueID, issueOM.getUniqueId());

        LOG.debug("Created new Issue: " + issueOM.getUniqueId());
        return issueOM;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueEvent(final XmlModule module, final XmlIssue issue)
        throws TorqueException,ScarabException,ParseException
    {
/////////////////////////////////////////////////////////////////////////////////  
        // Get me an issue
        Issue issueOM = null;
        final String issueID = (issue.hasModuleCode() ? "" : module.getCode()) + issue.getId();
        if (getImportTypeCode() == CREATE_SAME_DB || getImportTypeCode() == CREATE_DIFFERENT_DB)
        {
            // Check if the new issue nominates an ID and if the database does
            // not already contain an issue with that ID
            if (issue.getId() != null && IssueManager.getIssueById(issueID) == null)
            {
                // Create the new issue with the nominated ID
                issueOM = createNewIssue(module, issue, issue.getId());
            }
            else
            {
                // Crate the new issue with an automatically allocated ID
                issueOM = createNewIssue(module, issue, null);
            }
        }
        else if (getImportTypeCode() == UPDATE_SAME_DB) // nice to specify just for searching/refactoring
        {
            issueOM = IssueManager.getIssueById(issueID);
            
            if (issueOM == null)
            {
                issueOM = createNewIssue(module, issue, null);
            }
            else
            {
                LOG.debug("Found Issue in db: " + issueOM.getUniqueId());
            }
        }

/////////////////////////////////////////////////////////////////////////////////  

        // Loop over the XML activitySets
        final List activitySets = issue.getActivitySets();
        LOG.debug("-----------------------------------");
        LOG.debug("Number of ActivitySets in Issue: " + activitySets.size());
        for (Iterator itr = activitySets.iterator(); itr.hasNext();)
        {
            final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
            LOG.debug("Processing ActivitySet: " + activitySet.getId());

/////////////////////////////////////////////////////////////////////////////////  
            // Deal with the attachment for the activitySet
            final XmlAttachment activitySetAttachment = activitySet.getAttachment();
            Attachment activitySetAttachmentOM = null;
            if (activitySetAttachment != null)
            {
                if (getImportTypeCode() == UPDATE_SAME_DB)
                {
                    try
                    {
                        activitySetAttachmentOM = AttachmentManager
                            .getInstance(activitySetAttachment.getId());
                        LOG.debug("Found existing ActivitySet Attachment");
                    }
                    catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
                }
                else
                {
                    activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    LOG.debug("Created ActivitySet Attachment object");
                }
            }
            else
            {
                LOG.debug("OK- No Attachment in this ActivitySet");
            }

/////////////////////////////////////////////////////////////////////////////////  
            // Attempt to get the activitySet OM
            boolean alreadyCreated = false;
            ActivitySet activitySetOM = null;
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                try
                {
                    activitySetOM = ActivitySetManager.getInstance(activitySet.getId());
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in db: " + activitySetOM.getActivitySetId());
                }
                catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            }
            else
            {
                // first try to get the ActivitySet from the internal map
                if (activitySetIdMap.containsKey(activitySet.getId()))
                {
                    activitySetOM = ActivitySetManager.getInstance(
                        (String)activitySetIdMap.get(activitySet.getId()));
                    alreadyCreated = true;
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in map: " + activitySetOM.getActivitySetId());
                }
                else // it hasn't been encountered previously
                {
                    activitySetOM = ActivitySetManager.getInstance();
                    LOG.debug("Created new ActivitySet");
                }
            }

            final ScarabUser activitySetCreatedByOM = findUser(activitySet.getCreatedBy());
            
            if (LOG.isDebugEnabled())
            {
                LOG.debug("ActivitySet: " + activitySet.getId() + "; of type: " + activitySet.getType() + "; by: " + activitySet.getCreatedBy());
                LOG.debug("   alreadyCreated: " + alreadyCreated);
            }
            
            if (!alreadyCreated)
            {
                // Populate the ActivitySet
                // Get the ActivitySet type/createdby values (we know these are valid)
                final ActivitySetType ttOM = ActivitySetTypeManager.getInstance(activitySet.getType());
                activitySetOM.setActivitySetType(ttOM);
                if( activitySetCreatedByOM != null ){
                    activitySetOM.setCreatedBy(activitySetCreatedByOM.getUserId());
                }
                else
                {
                	// Anonymous user. better than nothing.
                	try {
						activitySetOM.setCreatedBy(ScarabUserManager.getAnonymousUser().getUserId());
					} catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                }
                activitySetOM.setCreatedDate(activitySet.getCreatedDate().getDate());
                if (activitySetAttachmentOM != null)
                {
                    activitySetAttachmentOM.save();
                    activitySetOM.setAttachment(activitySetAttachmentOM);
                }
                activitySetOM.save();
                if( activitySet.getId() != null){
                    // if id is valid, save for later re-use.
                    activitySetIdMap.put(activitySet.getId(), 
                                         activitySetOM.getPrimaryKey().toString());
                }
            }

            // Determine if this ActivitySet should be marked as the 
            // creation event
            final ActivitySet creationSet = issueOM.getActivitySetRelatedByCreatedTransId();
            if (ActivitySetTypePeer.CREATE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) 
               ||
               (ActivitySetTypePeer.MOVE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) && 
                        (creationSet == null || activitySetOM.getCreatedDate()
                         .before(creationSet.getCreatedDate()))) ) 
            {
                issueOM.setActivitySetRelatedByCreatedTransId(activitySetOM);
                issueOM.save();
            }

/////////////////////////////////////////////////////////////////////////////////  
// Deal with changing user attributes. this code needs to be in this *strange*
// location because we look at the entire activityset in order to determine
// that this is a change user activity set. of course in the future, it would
// be really nice to create an activityset/activiy type that more accurately 
// reflects what type of change this is. so that it is easier to case for. for
// now, we just look at some fingerprints to determine this information. -JSS

            if (activitySet.isChangeUserAttribute())
            {
                final List activities = activitySet.getActivities();
                final XmlActivity activityA = (XmlActivity)activities.get(0);
                final XmlActivity activityB = (XmlActivity)activities.get(1);
                
                final ScarabUser assigneeOM = findUser(activityA.getOldUser());
                final ScarabUser assignerOM = findUser(activityB.getNewUser());

                final Attribute oldAttributeOM = Attribute.getInstance(activityA.getAttribute());

                final AttributeValue oldAttValOM = issueOM.getUserAttributeValue(assigneeOM, oldAttributeOM);
                if (oldAttValOM == null)
                {
                    LOG.error("User '" + assigneeOM.getName() + "' was not previously '" + oldAttributeOM.getName() + "' to the issue!");
                }

                // Get the Attribute associated with the new Activity
                final Attribute newAttributeOM = Attribute.getInstance(activityB.getAttribute());

                issueOM.changeUserAttributeValue(activitySetOM,
                            assigneeOM, 
                            assignerOM, 
                            oldAttValOM,
                            newAttributeOM, null);
                LOG.debug("-------------Updated User AttributeValue------------");
                continue;
            }

/////////////////////////////////////////////////////////////////////////////////  

            // Deal with the activities in the activitySet
            final List activities = activitySet.getActivities();
            LOG.debug("Number of Activities in ActivitySet: " + activities.size());

            final LinkedMap avMap = issueOM.getModuleAttributeValuesMap();
            LOG.debug("Total Module Attribute Values: " + avMap.size());
            for (Iterator itrb = activities.iterator(); itrb.hasNext();)
            {
                final XmlActivity activity = (XmlActivity) itrb.next();
                LOG.debug("Looking at activity id: " + activity.getId());

                // Get the Attribute associated with the Activity
                final Attribute attributeOM = Attribute.getInstance(activity.getAttribute());

                // deal with the activity attachment (if there is one)
                final XmlAttachment activityAttachment = activity.getAttachment();
                Attachment activityAttachmentOM = null;
                if (activityAttachment != null)
                {
                    // look for an existing attachment in the activity
                    // the case is when we have a URL and we create it
                    // and then delete it, the attachment id is still the
                    // same so there is no reason to re-create the attachment
                    // again.
                    final String previousXmlId = activityAttachment.getId();
                    final String previousId = (String)attachmentIdMap.get(previousXmlId);
                    if (previousId == null) 
                    {
                        activityAttachmentOM = createAttachment(issueOM, activityAttachment);
                        activityAttachmentOM.save();
                        attachmentIdMap.put(previousXmlId, activityAttachmentOM.getPrimaryKey().toString());
                        
                        // Special case. After the Attachment object has been 
                        // saved, if the ReconcilePath == true, then assume 
                        // that the fileName is an absolute path to a file and
                        // copy it to the right directory
                        // structure under Scarab's path.
                        if (allowFileAttachments && activityAttachment.getReconcilePath())
                        {
                            try
                            {
                                activityAttachmentOM
                                    .copyFileFromTo(activityAttachment.getFilename(), 
                                                    activityAttachmentOM.getFullPath());
                            } 
                            catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            } 
                            catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                        }
                        LOG.debug("Created Activity Attachment object");
                    }
                    else 
                    {
                        activityAttachmentOM = AttachmentManager
                            .getInstance(previousId);
                        LOG.debug("Found existing Activity Attachment");
                    }
                }
                else
                {
                    LOG.debug("OK- No Attachment in this Activity");
                }

                // deal with null attributes (need to do this before we create the 
                // activity right below because this will create its own activity).
                if (attributeOM.equals(nullAttribute))
                {
                    // add any dependency activities to a list for later processing
                    if (isDependencyActivity(activity))
                    {
                        if (!isDuplicateDependency(activity))
                        {
                            final Object[] obj = {activitySetOM, activity, activityAttachmentOM};
                            allDependencies.add(obj);
                            dependActivitySetId.add(activity.getDependency());
                            LOG.debug("-------------Stored Dependency # " 
                                    + allDependencies.size() + '[' + activity.getDependency() + ']');
                            continue;
                        }
                    }
                    else
                    {
                        // create the activity record.
                        ActivityManager.createTextActivity(issueOM, nullAttribute, activitySetOM, 
                                    ActivityType.getActivityType(activity.getActivityType()), activity.getDescription(), activityAttachmentOM, 
                                    activity.getOldValue(), activity.getNewValue());
        
                        LOG.debug("-------------Saved Null Attribute-------------");
                        continue;
                    }
                }

                // create the activityOM
                createActivity(activity, module, 
                                            issueOM, attributeOM, activitySetOM);

                // check to see if this is a new activity or an update activity
                AttributeValue avalOM = null;
                for (Iterator moduleAttributeValueItr = avMap.mapIterator(); 
                     moduleAttributeValueItr.hasNext() && avalOM == null;)
                {
                    final AttributeValue testAvalOM = (AttributeValue)
                        avMap.get(moduleAttributeValueItr.next());
                    final Attribute avalAttributeOM = testAvalOM.getAttribute();

                    LOG.debug("Checking Attribute match: " + avalAttributeOM.getName() + 
                              " against: " + attributeOM.getName());
                    if (avalAttributeOM.equals(attributeOM))
                    {
                        avalOM = testAvalOM;
                    }
                }

                if (avalOM != null) 
                {
                    final Attribute avalAttributeOM = avalOM.getAttribute();
                    LOG.debug("Attributes match!");
                    AttributeValue avalOM2 = null;
                    if (!activity.isNewActivity())
                    {
                        LOG.debug("Activity is not new.");
                        avalOM2 = AttributeValue.getNewInstance(
                            avalAttributeOM.getAttributeId(), 
                            avalOM.getIssue());
                        avalOM2.setProperties(avalOM);
                    }

                    if (avalAttributeOM.isOptionAttribute())
                    {
                        LOG.debug("We have an Option Attribute: " + 
                                  avalAttributeOM.getName());
                        final AttributeOption newAttributeOptionOM = 
                                AttributeOptionManager.getInstance(
                                         attributeOM, activity.getNewOption(),
                                         issueOM.getModule(),
                                         issueOM.getIssueType());
                        if (activity.isNewActivity())
                        {
                            if (newAttributeOptionOM != null)
                            {
                                avalOM.setOptionId(newAttributeOptionOM.getOptionId());
                                avalOM.startActivitySet(activitySetOM);
                                avalOM.setAttribute(attributeOM);
                                avalOM.save();
                                LOG.debug("-------------Saved Attribute Value-------------");
                            }
                            else
                            {
                                LOG.warn("NewAttributeOptionOM is null for " +
                                         activity.getNewOption());
                            }
                        }
                        else if(newAttributeOptionOM != null)
                        {
                            avalOM2.setOptionId(newAttributeOptionOM.getOptionId());
                            final HashMap map = new HashMap();
                            map.put(avalOM.getAttributeId(), avalOM2);
                            issueOM.setAttributeValues(activitySetOM, map, null, activitySetCreatedByOM);
                            LOG.debug("-------------Saved Option Attribute Change-------------");
                        }
                    }
                    else if (avalAttributeOM.isUserAttribute())
                    {
                        LOG.debug("We have a User Attribute: " 
                                  + avalAttributeOM.getName());
                        if (activity.isNewActivity())
                        {
                            // Don't need to pass in the attachment because
                            // it is already in the activitySetOM.
                            // If we can't get an assignee new-user, then 
                            // use the activity set creator as assignee.
                            ScarabUser assigneeOM = findUser(activity.getNewUser());
                            assigneeOM = (assigneeOM != null)
                                ? assigneeOM: activitySetCreatedByOM;
                            if( assigneeOM != null ){
                                issueOM.assignUser(activitySetOM, 
                                    assigneeOM, null, avalAttributeOM, null);
                            }
                            LOG.debug("-------------Saved User Assign-------------");
                        }
                        else if (activity.isRemoveUserActivity())
                        {
                            // remove a user activity
                            final ScarabUser oldUserOM = findUser(activity.getOldUser());
                            // need to reset the aval because the current one
                            // is marked as new for some reason which causes an
                            // insert and that isn't the right behavior here 
                            // (we want an update)
                            avalOM = null;
                            for (Iterator i = issueOM.getAttributeValues(
                                 avalAttributeOM).iterator(); 
                                 i.hasNext() && avalOM == null;) 
                            {
                                final AttributeValue av = (AttributeValue)i.next();
                                if (oldUserOM.getUserId().equals(av.getUserId())) 
                                {
                                    avalOM = av;
                                }
                            }

                            if (avalOM == null) 
                            {
                                if (LOG.isDebugEnabled()) 
                                {
                                    LOG.debug("Could not find previous AttributeValue assigning " +
                                        (oldUserOM == null ? "NULL" : 
                                        oldUserOM.getUserName()) + 
                                        " to attribute " + 
                                              avalAttributeOM.getName());
                                }                                
                            }
                            else 
                            {
                                // don't need to pass in the attachment because
                                // it is already in the activitySetOM
                                issueOM.deleteUser(activitySetOM, oldUserOM, 
                                    activitySetCreatedByOM, avalOM, null);
                                LOG.debug("-------------Saved User Remove-------------");
                            }
                        }
                    }
                    else if (avalAttributeOM.isTextAttribute() || avalAttributeOM.isIntegerAttribute())
                    {
                        LOG.debug("We have a Text Attribute: " + avalAttributeOM.getName());

                        avalOM.startActivitySet(activitySetOM);
                        avalOM.setAttribute(attributeOM);

                        if (activity.isNewActivity())
                        {
                            avalOM.setValue(activity.getNewValue());
                        }
                        else if (!activity.getNewValue()
                                .equals(avalOM.getValue()))
                        {
                            avalOM2.setValue(activity.getNewValue());
                            avalOM.setProperties(avalOM2);
                        }
                        
                        avalOM.save();
                        LOG.debug("-------------Saved Attribute Value-------------");
                    }
                }
                issueOM.save();
                LOG.debug("-------------Saved Issue-------------");
            }
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Activity createActivity(final XmlActivity activity,  
                                         final XmlModule module,
                                         final Issue issueOM, 
                                         final Attribute attributeOM,
                                         final ActivitySet activitySetOM)
        throws TorqueException, ParseException, ScarabException
    {
        Activity activityOM = null;
        if (getImportTypeCode() == UPDATE_SAME_DB)
        {
            try
            {
                activityOM = ActivityManager.getInstance(activity.getId());
            }
            catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
        }
        else
        {
            activityOM = ActivityManager.getInstance();
        }

        activityOM.setIssue(issueOM);
        activityOM.setAttribute(attributeOM);
        activityOM.setActivityType(ActivityType.OTHER.getCode());
        activityOM.setActivitySet(activitySetOM);
        if (activity.getEndDate() != null)
        {
            activityOM.setEndDate(activity.getEndDate().getDate());
        }

        // Set the attachment for the activity
        Attachment newAttachmentOM = null;
        if (activity.getAttachment() != null)
        {
            newAttachmentOM = createAttachment(issueOM, activity.getAttachment());
            newAttachmentOM.save();
            activityOM.setAttachment(newAttachmentOM);
        }

        LOG.debug("Created New Activity");
        return activityOM;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Attachment createAttachment(final Issue issueOM, 
            final XmlAttachment attachment)
        throws TorqueException, ScarabException, ParseException
    {
        final Attachment attachmentOM = AttachmentManager.getInstance();
        attachmentOM.setIssue(issueOM);
        final AttachmentType type = AttachmentType.getInstance(attachment.getType());
        if (allowFileAttachments || !Attachment.FILE__PK.equals(type.getAttachmentTypeId())) 
        {
            attachmentOM.setName(attachment.getName());
            attachmentOM.setAttachmentType(type);
            attachmentOM.setMimeType(null != attachment.getMimetype()
                    ? attachment.getMimetype()
                    : ComponentLocator.getMimeTypeService().getContentType(attachment.getFilename(), null));
            attachmentOM.setFileName(attachment.getFilename());        
            attachmentOM.setData(attachment.getData());
        }
        else 
        {
            // add a comment that the file will not be imported.  An alternative would be
            // to skip the activity altogether, but we will then need to check that there 
            // are other activities or we need to completely ignore the ActivitySet
            attachmentOM.setName("comment");
            attachmentOM.setTypeId(Attachment.COMMENT__PK);
            attachmentOM.setMimeType("text/plain");
            String text = "File, " + attachment.getFilename() + 
                ", was not imported. The old description follows:\n\n" + attachment.getName();
            final String data = attachment.getData();  // this should be null, but just in case
            if (data != null) 
            {
                text += "\n\n" + data;
            }
            attachmentOM.setData(text);
        }
        
        attachmentOM.setCreatedDate(attachment.getCreatedDate().getDate());
        final ModifiedDate modifiedDate = attachment.getModifiedDate();
        if (modifiedDate != null)
        {
            attachmentOM.setModifiedDate(modifiedDate.getDate());
        }
        final ScarabUser creUser = findUser(attachment.getCreatedBy());
        if (creUser != null)
        {
            attachmentOM.setCreatedBy(creUser.getUserId());
        }

        final String modifiedBy = attachment.getModifiedBy();
        if (modifiedBy != null)
        {
            final ScarabUser modUserOM = findUser(attachment.getModifiedBy());
            if (modUserOM != null)
            {
                attachmentOM.setModifiedBy(modUserOM.getUserId());
            }
        }

        attachmentOM.setDeleted(attachment.getDeleted());
        return attachmentOM;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private ScarabUser findUser(final String userStr) 
        throws TorqueException,ScarabException
    {
        
        ScarabUser user = ScarabUserManager.getInstance(userStr);
        if (user == null && userStr != null && userStr.indexOf("@") <0 )
        {
            LOG.debug("user specified possibly by email address: "+userStr);
            // maybe it's an email not a username
            user = ScarabUserManager.getInstanceByEmail(userStr);
            LOG.debug("found "+user);
        }
        return user;        
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Module getModuleForIssue(final XmlModule module, final XmlIssue issue)
        throws TorqueException, ScarabException
    {
        
        if(issue.hasModuleCode() && !issue.getModuleCode().equals(module.getCode()) && !allowGlobalImport){
            throw new ScarabException(
                    new L10NKey("Lacking permission to cross-module import. Contact your administor. <localize me>"));
        }
        
        return issue.hasModuleCode()
                ? ModuleManager.getInstance(module.getDomain(),
                                            null,issue.getModuleCode())
                : ModuleManager.getInstance(module.getDomain(),
                                            module.getName(), module.getCode());
     }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected ScarabIssues insert(
            final String name, 
            final Reader is, 
            final BeanReader reader)
        throws ParserConfigurationException,SAXException,IOException,ScarabException, TorqueException
    {
        setValidationMode(reader, false);
        final ScarabIssues si = (ScarabIssues)reader.parse(is);
        si.doHandleDependencies();
        LOG.debug("Successfully imported " + name + '!');
        return si;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader getScarabFormattedReader(
            final Object input,
            final ImportType type,
            final Module currModule) throws IOException, TransformerException, TorqueException, JDOMException 
    {
        Reader returnValue = null;
        
        if( SCARAB == type )
        {
            // is in correct format already, just return the input stream
            returnValue = readerFor(input);
        }
        else if( BUGZILLA == type )
        {
            // Location of the extensions directory for Bugzilla
            // Transform configuration, mappings and attachments are here
            // TODO move onto resourceDirectory derivative
            final String extensions = System.getProperty("catalina.home") + "/../extensions/bugzilla";
            
            // Locate the Bugzilla to Scarab XSL transform
            final InputStream xsl = getClass().getResourceAsStream(BUGZILLA_XSL);
            
            // Transform Bugzilla xml to scarab format
            // (Trailing '/' to resources is deliberate)
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, extensions);
            
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        else if( JIRA == type )
        {
                    
            // transform xml to scarab format
            final InputStream xsl = getClass().getResourceAsStream(JIRA_XSL);
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, resourceDirectory);
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        return returnValue;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader insertModuleNode(final Reader result, 
            final Module currModule) 
        throws TorqueException, JDOMException, IOException, TransformerException 
    {
        
        final ScarabUser user = ScarabUserManager.getInstance(currModule.getOwnerId());        
        
        // Core Java: org.w3c.dom version (jdk1.4+ compatible)
//        final DocumentBuilder docBuilder = documentBuilderFactory.newDocumentBuilder();
//        final Document doc = docBuilder.parse( new InputSource(result) );
//        // insert module
//        final Element root = doc.getDocumentElement();
//        final Element moduleNode = doc.createElement("module");
//        final Element idNode = doc.createElement("id");
//        final Element parentIdNode = doc.createElement("parent-id");
//        final Element nameNode = doc.createElement("name");
//        final Element ownerNode = doc.createElement("owner");
//        final Element descriptionNode = doc.createElement("description");
//        final Element urlNode = doc.createElement("url");
//        final Element domainNode = doc.createElement("domain");
//        final Element codeNode = doc.createElement("code");
//        
//        idNode.appendChild(doc.createTextNode(String.valueOf(currModule.getModuleId())));
//        parentIdNode.appendChild(doc.createTextNode(String.valueOf(currModule.getParentId())));
//        nameNode.appendChild(doc.createTextNode(currModule.getName()));
//        ownerNode.appendChild(doc.createTextNode(user.getUserName()));
//        descriptionNode.appendChild(doc.createTextNode(currModule.getDescription()));
//        urlNode.appendChild(doc.createTextNode(currModule.getUrl()));
//        domainNode.appendChild(doc.createTextNode(currModule.getHttpDomain()));
//        codeNode.appendChild(doc.createTextNode(currModule.getCode()));
//        
//        moduleNode.appendChild(idNode);
//        moduleNode.appendChild(parentIdNode);
//        moduleNode.appendChild(nameNode);
//        moduleNode.appendChild(ownerNode);
//        moduleNode.appendChild(descriptionNode);
//        moduleNode.appendChild(urlNode);
//        moduleNode.appendChild(domainNode);
//        moduleNode.appendChild(codeNode);
//        
//        root.appendChild(moduleNode);
        
        // JDom version (jdk1.3 compatible)
        
        final SAXBuilder builder = new SAXBuilder();
        builder.setEntityResolver(new EntityResolver()
        {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }   
        });
        final Document doc = builder.build(result);        
        final Element root = doc.getRootElement();

        final Element moduleNode = new Element("module");
        final Element idNode = new Element("id");
        final Element parentIdNode = new Element("parent-id");
        final Element nameNode = new Element("name");
        final Element ownerNode = new Element("owner");
        final Element descriptionNode = new Element("description");
        final Element urlNode = new Element("url");
        final Element domainNode = new Element("domain");
        final Element codeNode = new Element("code");    
        
        idNode.setText(String.valueOf(currModule.getModuleId()));
        parentIdNode.setText(String.valueOf(currModule.getParentId()));
        nameNode.setText(currModule.getRealName());
        ownerNode.setText(user.getUserName());
        descriptionNode.setText(currModule.getDescription());
        urlNode.setText(currModule.getUrl());
        domainNode.setText(currModule.getHttpDomain());
        codeNode.setText(currModule.getCode());
        
        moduleNode.addContent(idNode)
                .addContent(parentIdNode)
                .addContent(nameNode)
                .addContent(ownerNode)
                .addContent(descriptionNode)
                /*
                 * These are excluded for now, since your database domain may 
                 * not correspond to currModule.getHttpDomain().
                .addContent(urlNode)
                .addContent(domainNode)
                 */
                .addContent(codeNode);
        root.addContent(2,moduleNode);
        
        return transformXML(new JDOMSource(doc), null, currModule, null);
    }
              
// in java/org/tigris/scarab/util/IssueIdParser.java
public static List getIssueIdTokens(Module module, String text)
        throws TorqueException
    {
        List result = new ArrayList();
        RE re = new RE(module.getIssueRegex());
        re.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
        int pos = 0;
        while (re.match(text, pos))
        {
            Log.get().debug(re.getParen(0) + " found at " + re.getParenStart(0));
            result.add(re.getParen(0));
            pos = re.getParenEnd(0);
        }

        return result;
    }
              
// in java/org/tigris/scarab/util/IssueIdParser.java
public static List tokenizeText(Module module, String text)
        throws TorqueException
    {
        List result = new ArrayList();
        RE re = new RE(module.getIssueRegex());
        re.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
        int pos = 0;
        while (re.match(text, pos))
        {
            Log.get().debug(re.getParen(0) + " found at " + re.getParenStart(0));
            // Add any text that did not contain an id
            if (re.getParenStart(0) > pos) 
            {
                result.add(text.substring(pos, re.getParenStart(0))); 
            }
                
            String token = re.getParen(0);
            String id = getIssueIdFromToken(module, token);
            if (id == null)
            {
                result.add(token);
            }
            else 
            {
                List tokenId = new ArrayList(2);
                tokenId.add(token);
                tokenId.add(id);
                result.add(tokenId);
            }
            
            pos = re.getParenEnd(0);
        }

        if (pos < text.length()) 
        {
            result.add(text.substring(pos));
        }
            
        return result;
    }
              
// in java/org/tigris/scarab/util/IssueIdParser.java
public static Map getIssueIds(Module module, String text)
        throws TorqueException
    {
        List tokens = getIssueIdTokens(module, text);
        Map idMap = new HashMap(presizeMap(tokens.size()));
        Iterator i = tokens.iterator();
        while (i.hasNext()) 
        {
            String token = (String)i.next();
            String id = getIssueIdFromToken(module, token);
            if (id != null) 
            {
                idMap.put(token, id);
            }
        }
        return idMap;
    }
              
// in java/org/tigris/scarab/util/word/QueryResult.java
public final Issue getIssue()
        throws TorqueException
        {
    	return IssueManager.getInstance(issueId);
    }
              
// in java/org/tigris/scarab/util/word/QueryResult.java
public final String getUniqueId()
        throws TorqueException
    {
        return getIssue().getUniqueId();
    }
              
// in java/org/tigris/scarab/util/word/QueryResult.java
public final List getAttributeValues()
        throws TorqueException
    {
        if(attributeValues==null)
        {
            attributeValues = new ArrayList();
            for(int j=0;j<issueListAttributeColumns.size();j++)
            {
                RModuleUserAttribute rmua = (RModuleUserAttribute)issueListAttributeColumns.get(j);

                List value = null;
                if(rmua.isInternal())
                {
                	String attributeId = rmua.getInternalAttribute();
                    value = getInternalAttributeValue(attributeId);
                }
                else
                {
                    Integer attributeId = rmua.getAttributeId();                
                    value = getAttributeValue(attributeId);
                }                    
                attributeValues.add(value);
            }                                
        }        
        return attributeValues;
    }
              
// in java/org/tigris/scarab/util/word/QueryResult.java
private List getAttributeValue(Integer attributeId)
        throws TorqueException
	{
        List value = new ArrayList();
        List attributeValue = getIssue().getAttributeValues(attributeId);
        String singleValue = null;
        
        if(attributeId.equals(sortAttrId))
	    {
	    	if(sortValueId!=null)
	    	{
	    		AttributeValue sortValue = AttributeValueManager.getInstance(sortValueId);
	    		singleValue = sortValue.getDisplayValue(L10N);	    		
	    	}
	    	else
	    	{
	    		singleValue = "";
	    	}
        	value.add(singleValue);
	    }
	    else
	    {
            for(int i=0;i<attributeValue.size();i++)
		    {
		        singleValue = ((AttributeValue)attributeValue.get(i)).getDisplayValue(L10N);
		        value.add( singleValue );
		    }
		}
		return value;
	}
              
// in java/org/tigris/scarab/util/word/QueryResult.java
private List getInternalAttributeValue(String attributeId)
        throws TorqueException
	{
        List value = new ArrayList();
        if (attributeId.equals(RModuleUserAttribute.CREATED_BY.getName()))
        {
            ScarabUser user = getIssue().getCreatedBy();
            value.add(user.getUserName());
        }
        else if (attributeId.equals(RModuleUserAttribute.CREATED_DATE.getName()))
        {
            DateFormat df = new SimpleDateFormat(L10NKeySet.ShortDatePattern.getMessage(L10N));
            value.add(df.format(getIssue().getCreatedDate()));
        }
        else if (attributeId.equals(RModuleUserAttribute.MODIFIED_BY.getName()))
        {
            ScarabUser user = getIssue().getModifiedBy();
            value.add(user.getUserName());
        }
        else if (attributeId.equals(RModuleUserAttribute.MODIFIED_DATE.getName()))
        {
            DateFormat df = new SimpleDateFormat(L10NKeySet.ShortDatePattern.getMessage(L10N));
            value.add(df.format(getIssue().getModifiedDate()));
        }
        else if (attributeId.equals(RModuleUserAttribute.MODULE.getName()))
        {
            value.add(getIssue().getModule().getRealName());
        }
        else if (attributeId.equals(RModuleUserAttribute.ISSUE_TYPE.getName()))
        {
            IssueType isueType = getIssue().getIssueType();
            value.add(isueType.getDisplayName(getIssue().getModule()));
        }
		return value;
	}
              
// in java/org/tigris/scarab/util/word/QueryResult.java
public final List getAttributeValuesAsCSV()
        throws TorqueException
    {
        List result = null;
        if (getAttributeValues() != null) 
        {
            result = new ArrayList(getAttributeValues().size());
            for (Iterator i = getAttributeValues().iterator(); i.hasNext();) 
            {
                List multiVal = (List)i.next();
                String csv = StringUtils.join(multiVal.iterator(), ", ");
                if(csv.indexOf('\n') > -1)
                {
                    csv = csv.replace('\n', '.');
                }
                if(csv.indexOf('\r') > -1)
                {
                    csv = csv.replace('\r', '.');
                }
                result.add(csv);
            }
        }            
        return result;
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private Document document(Issue issue)
            throws TorqueException
    {
        String issueId = issue.getIssueId().toString();
        Document doc = new Document();
        doc.add(new Field( ISSUE_ID, issueId, Field.Store.YES, Field.Index.UN_TOKENIZED ));

        for(Iterator as = issue.getAttachments().iterator(); as.hasNext();)
        {
            Attachment a = (Attachment)as.next();
            if (    a.getTypeId().equals(AttachmentTypePeer.COMMENT_PK)
                && !a.getDeleted()) 
            {
                doc.add(new Field( COMMENT, a.getData(), Field.Store.YES, Field.Index.TOKENIZED ));                
            }
        }
        
        for(Iterator vs = issue.getAttributeValuesMap().values().iterator(); vs.hasNext();)
        {
            AttributeValue v = (AttributeValue)vs.next();
            if(    v instanceof StringAttribute
               && !v.getDeleted())
            {
                doc.add(new Field( ATTRIBUTE_ID + v.getAttributeId().toString(), v.getValue(), Field.Store.YES, Field.Index.TOKENIZED ));
            }
        }
        return doc;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public static ScarabUser getSearchingUserPlaceholder()
        throws TorqueException
    {
        if(searchingUserPlaceholder==null)
        {
            searchingUserPlaceholder = ScarabUserManager.getInstance();
            searchingUserPlaceholder.setFirstName("");
            searchingUserPlaceholder.setLastName(SEARCHING_USER_KEY);
            searchingUserPlaceholder.setUserName(SEARCHING_USER_KEY);
            searchingUserPlaceholder.setEmail("");
        }
        return searchingUserPlaceholder;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addMITCriteria(Criteria crit)
        throws org.apache.torque.TorqueException
    {   
        mitList.addToCriteria(crit);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void setupSortColumn(Criteria crit, Integer sortAttrId)
        throws TorqueException
    {           
        crit.addAlias(SORT_TABLE, AttributeValuePeer.TABLE_NAME);

        joinAttributeValue(crit, SORT_TABLE, sortAttrId, Criteria.LEFT_JOIN);

        crit.addSelectColumn(useAlias(SORT_TABLE, AttributeValuePeer.VALUE_ID));

        String sortColumn;
        Attribute att = AttributeManager.getInstance(sortAttrId); 

        if (att.isOptionAttribute())
        {
            crit.addJoin(
                IssuePeer.MODULE_ID, 
                RModuleOptionPeer.MODULE_ID
                + ( " AND " 
                +  IssuePeer.TYPE_ID + " = " + RModuleOptionPeer.ISSUE_TYPE_ID +
                " AND " + RModuleOptionPeer.OPTION_ID + " = " + useAlias(SORT_TABLE, AttributeValuePeer.OPTION_ID)
                ).replace('.', DOT_REPLACEMENT_IN_JOIN_CONDITION ), 
                Criteria.LEFT_JOIN
            );
            sortColumn = RModuleOptionPeer.PREFERRED_ORDER;
        }
        else 
        {
            sortColumn = useAlias(SORT_TABLE, AttributeValuePeer.VALUE);
        }
        
        addSortColumn(crit, sortColumn);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addSortCriteria(Criteria crit)
        throws org.apache.torque.TorqueException
    {
        Integer sortAttrId = getSortAttributeId();
        String sortInternal = getSortInternalAttribute();
        
        if (sortAttrId != null) 
        {
            setupSortColumn(crit, sortAttrId);
        }
        else if (sortInternal != null)
        {
            setupInternalSortColumn(crit, sortInternal);
        }
        else
        {
        	addSortColumn(crit, IssuePeer.ISSUE_ID);
        }
        crit.addAscendingOrderByColumn(IssuePeer.ISSUE_ID);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public void addAttributeValue(Attribute attribute, String value)
    	throws TorqueException
    {
        AttributeValue av = AttributeValue.getNewInstance(attribute,searchIssue);
        av.setValue(value);
        searchIssue.addAttributeValue(av);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public AttributeValue addAttributeValue(Attribute attribute, AttributeOption option)
        throws TorqueException
    {
        AttributeValue av = AttributeValue.getNewInstance(attribute, searchIssue);
        av.setAttributeOption(option);
        searchIssue.addAttributeValue(av);
        return av;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getAttributeValues()
        throws TorqueException
    {
    	return searchIssue.getAttributeValues();
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getSetAttributeValues() throws TorqueException {
		return removeUnsetValues(searchIssue.getAttributeValues());
	}
              
// in java/org/tigris/scarab/util/Email.java
public static ScarabUser getArchiveUser()
        throws TorqueException
    {
        if(archiveUser==null)
        {
            archiveUser = ScarabUserManager.getInstance();
            archiveUser.setUserId(ARCHIVE_USER_ID);         
        }
        return archiveUser;
    }
(Lib) RuntimeException 38 
              
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
public void invoke(RunData data, ValveContext context) throws IOException, TurbineException
    {
        try
        {
    	   if (bNTLMActive &&
                   (
                   ((null == data.getUserFromSession() || data.getUserFromSession().getUserName().trim().length()==0) && null == data.getUser())
                   || ((ScarabUser)data.getUserFromSession()).isUserAnonymous()
                   )
                   && ( !data.getAction().equals("Logout")
                           && !data.getAction().equals("Login")
                           && !data.getTarget().equals("Register.vm")
                           && !data.getTarget().equals("ForgotPassword.vm")
                    ))
            {
                authenticateNtlm(data);
            }
        }
        catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
    	   context.invokeNext(data);       
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private List<RModuleAttribute> getRModuleUserAttributes(ScarabUser user, Module module, IssueType issueType, MITList currentList) 
    {
        List<RModuleAttribute> issueListColumns = null;
        try {
            //
            // First check whether an MIT list is currently
            // active and if so, whether it has attributes
            // associated with it.
            //
            if (currentList != null) {
                //
                // Here we fetch the collection of attributes
                // associated with the current MIT list.
                //

                //issueListColumns = currentList.getCommonRModuleUserAttributes();
                ensure_List_has_MIT_data(currentList, module, issueType);
                issueListColumns = currentList.getAllRModuleUserAttributes();

                //
                // If there are no attributes associated with
                // the list, and the list only contains a single
                // module and a single issue type, get the default
                // attributes for that combination of module and
                // issue type.
                //
                if (issueListColumns.isEmpty()
                        && currentList.isSingleModuleIssueType()) {
                    issueListColumns = currentList.getModule()
                            .getDefaultRModuleUserAttributes(
                                    currentList.getIssueType());
                }

                // TODO repeat the above when single module but two or more issuetypes
                // TODO looking for common default attributes.
            }

            if (issueListColumns == null || issueListColumns.size() == 0)
            {
                issueListColumns = user.getRModuleUserAttributes(module, issueType);
                if (issueListColumns.isEmpty()) 
                {
                    issueListColumns = module.getDefaultRModuleUserAttributes(issueType);
                }
            }
            
            if (issueListColumns == null)
            {
                issueListColumns = Collections.EMPTY_LIST;
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        return issueListColumns;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getCurrentSearchResults()
    {
        List queryResults = Collections.EMPTY_LIST;
        try
        {
            queryResults = getUnprotectedCurrentSearchResults();
            if (queryResults.size() == 0)
            {
                setInfoMessage(L10NKeySet.NoMatchingIssues);
            }
        }
        catch (ScarabException e)
        {
            setAlertMessage(e.getL10nMessage());
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }

        return queryResults;
    }
              
// in java/org/tigris/scarab/search/CachedQuery.java
public List getResults()
    {
        if(countOnly)
        	throw new RuntimeException("is countOnly!");

        if(results==null)
    		results = new CachedResultList(this);
    	
    	return results;
    }
              
// in java/org/tigris/scarab/search/CachedQuery.java
public void cacheInitial()
    {
    	if(cachedRows==null)
    	{
    		try
    		{
				if(!countOnly)
	    		{
	    	        criteria.setLimit(-1).setOffset(0);
	    	    	String sql = adjustSelectSql(BasePeer.createQueryString(criteria));
	    		    cachedRows = executeSelect(sql);
	    		}	    		

				if(cachedRows==null) cachedRows = new ArrayList();
	
	            totalRowCount = cachedRows.size(); 
    		
			    if(countOnly)
			    {
	    	        criteria.setLimit(-1).setOffset(0);
	    	    	String sql = adjustSelectSql(BasePeer.createQueryString(criteria));
			        sql = makeCountSql(sql);
	                List countRows = executeSelect(sql);
	                Record countRow = (Record)countRows.get(0);   
	                totalRowCount = countRow.getValue(1).asInt();
			    }
    		}
		    catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
    	}
    }
              
// in java/org/tigris/scarab/search/CachedQuery.java
public void cacheAll()
	{
		if(cachedRows==null)
			cacheInitial();
		
    	if(cachedRowCount() < totalRowCount())
		{
    		try
    		{
		        criteria.setLimit(-1).setOffset(cachedRowCount());
		    	String sql = adjustSelectSql(BasePeer.createQueryString(criteria));
			    cachedRows.addAll(executeSelect(sql));
		    }
			catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
	        
		}
	}
              
// in java/org/tigris/scarab/attribute/UserAttribute.java
public String getValue()
    {
        try
        {
            ScarabUser user = getScarabUser();
            if(user!=null)
                return user.getUserName();
            else
                return null;
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
              
// in java/org/tigris/scarab/attribute/UserAttribute.java
public void setValue(final String username)  
    {
        try
        {
            if (username != null) 
                setUserIdOnly(
                    ScarabUserManager.getInstance(username).getUserId()
                );
            else
                setUserIdOnly(null);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
              
// in java/org/tigris/scarab/om/AttributeValue.java
public AttributeValue copy(Connection con) throws TorqueException 
    {
        throw new RuntimeException("Unimplemented method AttributeValue:copy(Connection conn)");
        //return copy();
    }
              
// in java/org/tigris/scarab/om/Activity.java
public String getNewValue(Issue issue, ScarabLocalizationTool l10n)
        throws Exception
    {
        String value = null;
        ActivityType activityType = getType();
        String newValue = getNewValue();
        
        if(   ActivityType.DEPENDENCY_CREATED.equals(activityType)
           || ActivityType.DEPENDENCY_CHANGED.equals(activityType))
        {
            if(newValue == null)
            {
                throw new RuntimeException("Dependency creation/change needs a new value. (Does imply that Dependency deletion is NOT supported?). The Error occured in issue " 
                          + issue.getParents()+ issue.getIdCount() );
            }
        	if(issue != null 
        			&& issue.getIssueId().intValue() != getDepend().getIssueRelatedByObservedId().getIssueId().intValue()
        			&& "blocking".equals(newValue))
        	{
            	value = getDepend().getIssueRelatedByObserverId().getUniqueId()
                + " " + l10n.get("DependsOn") //deprecated, but method is used many times in scarab.
            	+ " " + getDepend().getIssueRelatedByObservedId().getUniqueId(); 
            }
            else
            {
            	value = getDepend().getIssueRelatedByObservedId().getUniqueId()
            	+ " " + ("blocking".equals(newValue) ? l10n.get("PrerequisiteFor") : l10n.get(DependTypeManager.getManager().getL10nKey(newValue)))
                + " " + getDepend().getIssueRelatedByObserverId().getUniqueId();  
            }
        } 
        else if( ActivityType.ATTACHMENT_CREATED.equals(activityType))
        {
            value = getAttachment().getFileName();
        }
        else if(    ActivityType.URL_ADDED.equals(activityType)
                || ActivityType.COMMENT_ADDED.equals(activityType))
        {
            value = getAttachment().getData();
        }
        else if( ActivityType.COMMENT_CHANGED.equals(activityType))
        {
            value = newValue!=null ? firstChars( newValue, 50 ) : "";
        }
        else if( getType().equals(ActivityType.OTHER))
        {
            value = super.getDescription()!=null ? super.getDescription() : "";
        } 
        else 
        {
        	//assumption that an attribute was changed
        	if(getAttribute() != null && getAttribute().isDateAttribute())
        	{
        		value = DateAttribute.dateFormat(newValue!=null ? newValue : "",  L10NKeySet.ShortDateDisplay.getMessage(l10n));
        	}
        	else
        	{
        		value = newValue!=null ? newValue : "";
        	}            
        }
        return value;
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public Integer getConditionOperator()
    {
        Integer operator = 0;
        List<Condition> conditions;
        try {
            conditions = getConditions();
        } catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        if(conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getAnonymousUser()
	    throws TorqueException
	{
		ScarabUser user = null;
	    if(anonymousAccessAllowed())
	    {
	        String username = getAnonymousUserName();
	        user = getInstance(username);
	    }
	    if (user == null)
	    {
	        try
	        {
	    	    user = (ScarabUser) TurbineSecurity.getAnonymousUser();
	        }
	        catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
	    }
	    return user;
	}
              
// in java/org/tigris/scarab/om/ScarabModule.java
public ScarabUser[] getUsers(List permissions)
    {
        ScarabUser[] result = null;
        Object obj = ScarabCache.get(this, GET_USERS, 
                                     (Serializable)permissions); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.setDistinct();
            if (permissions.size() == 1) 
            {
                crit.add(TurbinePermissionPeer.NAME, permissions.get(0));
            }
            else if (permissions.size() > 1)
            {
                crit.addIn(TurbinePermissionPeer.NAME, permissions);
            }      
            
            if (permissions.size() >= 1)
            {
                ArrayList groups = new ArrayList(2);
                groups.add(getModuleId());
                groups.add(ROOT_ID);
                crit.addJoin(TurbinePermissionPeer.PERMISSION_ID, 
                             TurbineRolePermissionPeer.PERMISSION_ID);
                crit.addJoin(TurbineRolePermissionPeer.ROLE_ID, 
                             TurbineUserGroupRolePeer.ROLE_ID);
                crit.addIn(TurbineUserGroupRolePeer.GROUP_ID, groups);
                crit.addJoin(ScarabUserImplPeer.USER_ID, 
                             TurbineUserGroupRolePeer.USER_ID);
                
                crit.add(ScarabUserImplPeer.getColumnName(User.CONFIRM_VALUE),(Object)ScarabUser.DELETED,Criteria.NOT_EQUAL);
                

                try
                {
                    User[] users = TurbineSecurity.getUsers(crit);
                    result = new ScarabUser[users.length];
                    for (int i=result.length-1; i>=0; i--) 
                    {
                        result[i] = (ScarabUser)users[i];
                    }
                }
                catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
            }
            else 
            {
                result = new ScarabUser[0];
            }
            ScarabCache.put(result, this, GET_USERS, 
                            (Serializable)permissions);
        }
        else 
        {
            result = (ScarabUser[])obj;
        }
        return result;
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public Role getRequiredRole()
    {
        Role role = null;
        try
        {
            String roleName = GlobalParameterManager
               .getString(GlobalParameter.REQUIRED_ROLE_FOR_REQUESTING_ACCESS, this);
            if (roleName != null && roleName.length() > 0)
                role = TurbineSecurity.getRole(roleName);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
        return role;
    }
              
// in java/org/tigris/scarab/om/NotificationStatus.java
public String getStatusLabel()
    {
        Integer status = getStatus();
        if (status.equals(WAIT)) return "wait";
        if (status.equals(SCHEDULED)) return "scheduled";
        if (status.equals(DEFERRED)) return "deferred";
        if (status.equals(FAIL)) return "fail";
        if (status.equals(SENT)) return "delivered";
        if (status.equals(MARK_DELETED)) return "deleted";
        if (status.equals(ON_HOLD)) return "onhold";
        throw new RuntimeException("Database inconsistency: status ["+status+"] is not known.");
    }
              
// in java/org/tigris/scarab/om/Transition.java
public Integer getConditionOperator()
    {
        Integer operator = 0;
        List<Condition> conditions;
        try {
            conditions = getConditions();
        } catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        if(conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
              
// in java/org/tigris/scarab/om/Attribute.java
public Integer getConditionOperator()
    {
        List<Condition> conditions;
        try {
            conditions = this.getConditions();
        } catch (TorqueException e) {
            throw new RuntimeException(e);
        }
        Integer operator = 0;
        if (conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void save(Connection dbCon)
        throws TorqueException
    {
        Module module = getModule();
        if (!module.allowsIssues() || (isNew() && !module.allowsNewIssues())) 
        {
            throw new UnsupportedOperationException(module.getName() + 
                " does not allow issues."); //EXCEPTION
        }
        
        // remove unset AttributeValues before saving
        List attValues = getAttributeValues();
        // reverse order since removing from list
        for (int i=attValues.size()-1; i>=0; i--) 
        {
            AttributeValue attVal = (AttributeValue) attValues.get(i);
            if (!attVal.isSet()) 
            {
                attValues.remove(i);
            }
        }

        if (isNew())
        {
            // set the issue id
            setIdDomain(module.getScarabInstanceId());
            setIdPrefix(module.getCode());

            // for an enter issue template, do not give issue id
            // set id count to -1 so does not show up as an issue
            if (isTemplate())
            { 
                setIdCount(-1);
            }
            else
            {
                try
                {
                    final int suggestedID = getIdCount();
                    if (suggestedID != 0) {
                        // Force the next available issue ID to be the
                        // nominated value, if not out of sequence.
                        // TODO: assert that this issue doesn't already exist
                        // In this case, just skip the next action.
                        setNextIssueId(dbCon, suggestedID);
                    }
                    
                    // Set the ID to the next available value.
                    setIdCount(getNextIssueId(dbCon));
                }
                catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        if(  getActivitySetRelatedByLastTransId()==null
           ||getActivitySetRelatedByCreatedTransId()==null)
        {
            throw new RuntimeException("Created or Last ActivitySet must not be null.");
        }
        super.save(dbCon);
    }
              
// in java/org/tigris/scarab/om/Issue.java
private void index()
    {
        try
        {
            SearchFactory.getInstance().index(this);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public Integer getConditionOperator()
    {
        Integer operator = 0;
        List<Condition> conditions;
        try {
            conditions = getConditions();
        } catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        if(conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
              
// in java/org/tigris/scarab/om/ModuleManager.java
public void addedObject(Persistent om)
    {
        try
        {
            if (om instanceof RModuleAttribute)
            {
                Module module = ((RModuleAttribute)om).getModule();
                getMethodResult().removeAll(module, AbstractScarabModule.GET_R_MODULE_ATTRIBUTES);
            }
            else if (om instanceof RModuleOption)
            {
                Module module = ((RModuleOption)om).getModule();
                getMethodResult().removeAll(module, AbstractScarabModule.GET_LEAF_R_MODULE_OPTIONS);
                getMethodResult().removeAll(module, AbstractScarabModule.GET_ALL_R_MODULE_OPTIONS);
            }
            else if (om instanceof RModuleIssueType) 
            {
                Module module = ((RModuleIssueType)om).getModule();
                getMethodResult().remove(module, AbstractScarabModule.GET_NAV_ISSUE_TYPES);
            }
            else if (om instanceof IssueType) 
            {
                getMethodResult().clear();
            }
            else if (om instanceof Attribute) 
            {
                getMethodResult().clear();
            }
            else if (om instanceof AttributeOption) 
            {
                getMethodResult().clear();
            }
            else if (om instanceof AttributeValue) 
            {
                Module module = ((AttributeValue)om).getIssue().getModule();
                getMethodResult().removeAll( module, ScarabModule.GET_DEFAULTREPORT);
            }
            else if (om instanceof Report) 
            {
                Module module = ((Report)om).getModule();
                if(module!=null)
                {
                    getMethodResult().removeAll(module, ScarabModule.GET_DEFAULTREPORT);
                }          
            }
        }
        catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
    }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private void createWakeupNotification(Issue issue, ScarabUser user, String wakeupMessage) throws TorqueException
    {
        Date date;
        try {
            date = issue.getOnHoldUntil();
        } catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            Activity activity = ActivityManager.getInstance();
            Attribute attribute = issue.getMyStatusAttribute();

            activity.setAttribute(attribute);
            activity.setActivityType(ActivityType.ISSUE_ONHOLD.getCode());
            activity.setDescription("WakeupFromOnHoldstate");
            activity.setIssue(issue);
            activity.setEndDate(date);
            activity.setNewValue("");
            activity.setOldValue("");
            activity.setOldOptionId(0);
            activity.setNewOptionId(0);
            
            Attachment attachment = AttachmentManager.getInstance();
            attachment.setTextFields(user, issue,Attachment.COMMENT__PK);
            attachment.setData(wakeupMessage);
            attachment.setName("comment");
            attachment.save();
            
            activity.setAttachment(attachment);
            
            Integer tt = ActivitySetTypePeer.EDIT_ISSUE__PK;
            ActivitySet activitySet;
            try {
                activitySet = ActivitySetManager.getInstance(tt, user);
                activitySet.addActivity(activity);
                activitySet.save();
                
                addActivityNotification(ActivityType.ISSUE_REMINDER, activitySet, issue, user);                
            } catch (ScarabException e) {
                throw new RuntimeException(e);
            }
    }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
public void addOnHoldNotification(ActivitySet activitySet, Issue issue, ScarabUser user)
    {
        Date date;
        try {
            date = issue.getOnHoldUntil();
            Activity activity = ActivityManager.getInstance();
            Attribute attribute = issue.getMyStatusAttribute();
            activity.setAttribute(attribute);
            activity.setActivityType(ActivityType.ISSUE_ONHOLD.getCode());
            activity.setIssue(issue);
            activity.setEndDate(date);
            activity.setNewValue("GeneratedOnHoldState");
            activity.setOldValue("");
            activity.setOldOptionId(0);
            activity.setNewOptionId(0);
            activity.setDescription("GeneratedOnHoldState");
            activitySet.addActivity(activity);
            activitySet.save();
            NotificationStatus notification = new NotificationStatus(user, activity);
            notification.setStatus(NotificationStatus.ON_HOLD);
            NotificationStatusPeer.doInsert(notification);
        } catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
        
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public Integer[] getConditionsArray() 
    {
        Integer[] entries = new Integer[conditions.size()];
        Iterator<Condition> iter;
        try {
            iter = getConditions().iterator();
        } catch (TorqueException e) {
            throw new RuntimeException(e);
        }
        int index = 0;
        while(iter.hasNext())
        {
            Condition condition = iter.next();
            entries[index] = condition.getConditionId().intValue();
        }
        return entries;
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public Integer getConditionOperator()
    {
        Integer operator = 0;
        List<Condition> conditions;
        try {
            conditions = getConditions();
        } catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        if(conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
              
// in java/org/tigris/scarab/notification/Notification.java
public boolean isConditioned()
    {
        boolean conditioned;
        try {
            conditioned = getConditions().size() > 0;
        } catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
        return conditioned;
    }
              
// in java/org/tigris/scarab/feeds/IssueFeed.java
private String createEntryTitle(Activity activity) {
        String displayName = null;
        try
        {
            displayName=activity.getDisplayName();
        }
        catch( Exception e)
        {
            throw new RuntimeException(e);
        }
		return displayName;
	}
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
private void setNoPermissionMessage()
    {        
        if(scarabR==null | l10n==null){
            throw new RuntimeException("setup() method not called for action event");
        }
        scarabR.setAlertMessage(
            l10n.get(NO_PERMISSION_MESSAGE));
    }
              
// in java/org/tigris/scarab/actions/Login.java
public static void simpleLogin(RunData data, ScarabUser user)
    {
        if(user.getUserName().equals("")) //is it a TurbineAnonymousUser?
        {
        	user.setHasLoggedIn(Boolean.FALSE);
        }
        else
        {
        	user.setHasLoggedIn(Boolean.TRUE);
            try
            {
                user.updateLastLogin();
            }
            catch(Exception e)
            {
                throw new RuntimeException(e);
            }
        }
        data.setUser(user);
        data.save();
    }
              
// in java/org/tigris/scarab/actions/Login.java
public static void anonymousLogin(RunData data)
    {
    	ScarabUser anonymous = null;
    	try
        {
        	anonymous = ScarabUserManager.getAnonymousUser();
        }
        catch(Exception e)
        {
            throw new RuntimeException(e);
        }
        simpleLogin(data, anonymous);
    }
              
// in java/org/tigris/scarab/actions/setup/AntRunner.java
private BuildLogger createLogger()
    {
        BuildLogger logger = null;
        if (loggerClassname != null)
        {
            try
            {
                logger = (BuildLogger) (Class.forName(loggerClassname)
                        .newInstance());
            }
            catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
            catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
        }
        else
        {
            logger = new DefaultLogger();
        }

        logger.setMessageOutputLevel(msgOutputLevel);
        logger.setOutputPrintStream(out);
        logger.setErrorPrintStream(err);
        logger.setEmacsMode(false);

        return logger;
    }
              
// in java/org/tigris/scarab/util/ScarabUtil.java
public static final String urlEncode(String in)
    {
        try
        {
            return URLEncoder.encode(in, "UTF-8");
        }
        catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void cancelRebuild()
    {
        try
        {
            synchronized(this)
            {
                if(isRebuildInProgress())
                {
                    rebuildMonitor.cancel();
                    rebuildThread.join(10000);
                }
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void run()
        {
            try
            {
                Log.get().info(REBUILDING + "started");
                rebuild(this);
                Log.get().info(REBUILDING + "finished");
            }
            catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }            
        }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void dispose()
    {
        try
        {
            synchronized(this)
            {
                cancelRebuild();
                close();
            }
        } 
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
        
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public Object get(int index)
        {
            Record next = (Record) queryResult.get(index);

            try
            {
	            Long issueId = new Long(next.getValue(1).asString());
	            Integer sortAttrId = getSortAttributeId();
	            Long sortValueId = null;
	            if(sortAttrId != null)
	            { 
	                String s = next.getValue(2).asString();
	                if(s!=null)
	                {
	                    sortValueId = new Long(s);	 
	                }                	 
	            }
	            return new QueryResult(issueId, issueListAttributeColumns, sortAttrId, sortValueId, L10N );
            }
            catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }
        }
32
              
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e) {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
              
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
              
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (ScarabException e) {
                throw new RuntimeException(e);
            }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
              
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/feeds/IssueFeed.java
catch( Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
            {
                throw new RuntimeException(e);
            }
              
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
              
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
              
// in java/org/tigris/scarab/util/ScarabUtil.java
catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }
0
(Lib) IllegalArgumentException 21 
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getIssues(List issueIds)
        throws Exception
    {
        List issues = null;
        StringBuffer invalidIds = null;
        if (issueIds == null || issueIds.isEmpty())
        {
            issues = Collections.EMPTY_LIST;
        }
        else
        {
            if (issueIds.get(0) instanceof String)
            {
                issues = new ArrayList(issueIds.size());
                Iterator i = issueIds.iterator();
                while (i.hasNext())
                {
                    String id = (String)i.next();
                    Issue issue = getIssue(id);
                    if (issue == null)
                    {
                        if (invalidIds == null)
                        {
                            invalidIds = new StringBuffer(id);
                        }
                        else
                        {
                            invalidIds.append(' ').append(id);
                        }
                    }
                    else
                    {
                        issues.add(issue);
                    }
                }
                if (invalidIds != null)
                {
                    setAlertMessage(getLocalizationTool()
                        .format("SomeIssueIdsNotValid", invalidIds.toString()));
                }
            }
            else if (issueIds.get(0) instanceof Long)
            {
                issues = new ArrayList(issueIds.size());
                Iterator i = issueIds.iterator();
                while (i.hasNext())
                {
                    Issue issue = IssueManager.getInstance((Long)i.next());
                    if (issue == null)
                    {
                        setAlertMessage(L10NKeySet.SomeIssuePKsNotValid);
                    }
                    else
                    {
                        issues.add(issue);
                    }
                }
            }
            else
            {
                throw new IllegalArgumentException(
                    "issue ids must be Strings or Longs, not " +
                    issueIds.get(0).getClass().getName()); //EXCEPTION
            }
        }
        return issues;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private ReportBridge getNewReport(MITList mitList)
        throws Exception
    {
        if (mitList == null)
        {
            throw new IllegalArgumentException(
                "Cannot create a new report without any issue types."); //EXCEPTION
        }

        ScarabUser user = (ScarabUser)data.getUser();
        org.tigris.scarab.om.Report om  = new org.tigris.scarab.om.Report();
        ReportBridge report = new ReportBridge(om);
        report.setGeneratedBy(user);
        report.setMITList(mitList);

        String key = ((ScarabUser)data.getUser()).setCurrentReport(report);
        data.getParameters().add(ScarabConstants.CURRENT_REPORT, key);

        return report;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public void setScarabUser(ScarabUser v) throws TorqueException
    {
        if (v == null)
        {
            throw new IllegalArgumentException("cannot set user to null."); //EXCEPTION
        }

        super.setScarabUser(v);
        aScarabUser = v;
        expandedList = null;
    }
              
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getInstanceFromIssueList(List issues, 
                                                   ScarabUser user)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        
        if (user == null) 
        {
            throw new IllegalArgumentException("Null user is not allowed."); //EXCEPTION
        }
        
        MITList list = getInstance();
        list.setScarabUser(user);
        List dupeCheck = list.getMITListItems();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            MITListItem item = MITListItemManager.getInstance();
            item.setModule(issue.getModule());
            item.setIssueType(issue.getIssueType());
            if (!dupeCheck.contains(item)) 
            {
                list.addMITListItem(item);
            }
        }
        
        return list;
    }
              
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
public static RModuleIssueType getInstance(String key)
        throws TorqueException
    {
        if (key == null) 
        {
            throw new NullPointerException(
                "Cannot request a RModuleIssueType using a null key."); //EXCEPTION
        }
        int colonPos = key.indexOf(':');
        if (colonPos == -1) 
        {
            throw new IllegalArgumentException(
                "RModuleIssueType keys must be of the form N1:N2, not " + key); //EXCEPTION
        }
        // { module_id, issue_type_id } 
        SimpleKey[] keyArray = { new NumberKey(key.substring(1, colonPos)), 
            new NumberKey(key.substring(colonPos+2, key.length()-1)) 
            };
        return getInstance(new ComboKey(keyArray));
    }
              
// in java/org/tigris/scarab/om/ModuleManager.java
public static List getInstancesFromIssueList(List issues)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        

        List modules = new ArrayList();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            if (issue != null)
            {
                Module module = issue.getModule();
                if (module != null && !modules.contains(module)) 
                {
                    modules.add(module);
                }
            }
            else
            {
                throw new TorqueException("Null issue in list is not allowed."); //EXCEPTION
            }
        }
        return modules;
    }
              
// in java/org/tigris/scarab/om/UserPreferenceManager.java
public static UserPreference getInstance(Integer userid)
        throws TorqueException
    {
        if (userid == null)
        {
            throw new IllegalArgumentException("User ID cannot be null"); //EXCEPTION
        }

        UserPreference up = null;
        try
        {
            up = BaseUserPreferenceManager.getInstance(userid);
        }
        catch (TorqueException te)
        {
            // Empty result...Failed to select one and only one row.
        }
        if (up == null)
        {
            up = UserPreferenceManager.getInstance();
            up.setUserId(userid);
        }
        return up;
    }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private LocalizationKey getStatusKey(NotificationStatus notification, Issue issue) 
    {
        LocalizationKey result = null;
        try
        {
            Attribute attribute = notification.getActivity().getAttribute();
            if (attribute == null || !getIsStatusAttribute(attribute, issue))
            {
                throw new IllegalArgumentException("Expected a notification containing a status attribute.");
            }

            String name = attribute.getName();
            AttributeValue av = issue.getAttributeValue(name);
            if(av != null)
            {
                result = new L10NKey(av.getValue()); // interpret the value as a L10NKey (for future use!)
            }
            else
            {
                throw new IllegalArgumentException("Received a notification containing a status attribute without a given value.");
            }
        }
        catch (TorqueException e)
        {
            Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
            Log.get().warn("db layer reported: ["+e.getMessage()+"]");
        }
        
        return result;
    }
              
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
public Vector changeIssueAttributeOption(final String issue,
            final String user, final String attribute, final String option,
            final String description)
    {

        log("changeIssueAttributeOption:  issue=" + issue + ", user=" + user
                + ", attribute=\"" + attribute + "\"" + ", option=\"" + option
                + "\"" + ", description=\"" + description + "\"");

        final Vector retValue = new Vector();
        try
        {
            // find issue
            final Issue i = IssueManager.getIssueById(issue);
            // find user
            final ScarabUser u = ScarabUserManager.getInstance(user);
            // find attribute
            final Attribute a = Attribute.getInstance(attribute);
            // find attributeOption
            final AttributeOption o = AttributeOptionManager.getInstance(a, option);
            // proper method call
            if( i == null || u == null || a == null || o == null )
            {
                throw new IllegalArgumentException("Encountered an invalid parameter: "+i+" , "+u+" , "+a+" , "+o);
            }
            retValue.add(new Boolean(changeIssueAttributeOption(i, u, a, o,
                    description)));
        }
        catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
        catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
        return retValue;
    }
              
// in java/org/tigris/scarab/screens/RSSDataExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
			throws Exception {
		super.doBuildTemplate(data, context);

		data.getResponse().setContentType(MIME_TYPE);

		// we will send the response, so no target to render
		data.setTarget(null);
		
		Writer writer = data.getResponse().getWriter();
		
		try {
            ParameterParser parser = data.getParameters();



            String feedType = parser.getString(FEED_TYPE_KEY);
            if(feedType == null)
            {
                String msg = COULD_NOT_FIND_FEED_TYPE;
                Log.get().error(msg);
                data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);            
                return;
            }

            String feedFormat = parser.getString(FEED_FORMAT_KEY);

            ScarabLink scarabLink= getScarabLinkTool(context);
            
            Feed feedSource = null;
            if (feedType.equals("IssueFeed")){
                String issueId = parser.getString(ISSUE_ID_KEY);                
                if(issueId.equals("")){
                    throw new IllegalArgumentException("Issue ID is missing.  Should be appended like: /issueId/xxx");
                }            	
            	Issue issue = IssueManager.getIssueById(issueId);
            	feedSource = new IssueFeed(issue,scarabLink, getLocalizationTool(context));
            }
            else {
            	throw new Exception("Couldn't find feed for type:" + feedType);
            }
            SyndFeed feed = feedSource.getFeed();

            feedFormat = (feedFormat!=null) ? feedFormat : DEFAULT_FEED_FORMAT;
            feed.setFeedType(feedFormat);

            
            SyndFeedOutput output = new SyndFeedOutput();
            output.output(feed,writer);
        }
        catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }        
        catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }      		
	}
              
// in java/org/tigris/scarab/reports/ReportAxis.java
public ReportHeading getHeading(int headingIndex)
    {
        ReportHeading heading;
        List headings = getReportHeadings();
        if (headingIndex >= 0)
        {
            if (headings == null || headings.size() <= headingIndex) 
            {
                throw new IllegalArgumentException(headingIndex + 
                    " is larger than the number of headings"); //EXCEPTION
            }
            else 
            {
                heading = (ReportHeading)headings.get(headingIndex);
            }
        }
        else 
        {
            heading = new ReportHeading();
            addReportHeading(heading);
        }
        return heading;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
void doHandleDependencies()
        throws ScarabException, TorqueException
    {
        LOG.debug("Number of dependencies found: " + allDependencies.size());
        for (Iterator itr = allDependencies.iterator(); itr.hasNext();)
        {
            final Object[] data = (Object[])itr.next();
            final ActivitySet activitySetOM = (ActivitySet) data[0];
            final XmlActivity activity = (XmlActivity) data[1];
            

            final Dependency dependency = activity.getDependency();
            final String child = (String)issueXMLMap.get(dependency.getChild());
            final String parent = (String)issueXMLMap.get(dependency.getParent());
            if (parent == null || child == null)
            {
                if(null != parent || null != child)
                {
                    // add a comment into the issue that informs of the dependency
                    final Issue issueOM = IssueManager.getIssueById(null == parent ? child : parent);
                    final Attachment attachmentOM = new Attachment();
                    attachmentOM.setName("comment");
                    attachmentOM.setTypeId(Attachment.COMMENT__PK);
                    attachmentOM.setMimeType("text/plain");
                    // TODO i18n this
                    final String text = "Dependency \"" 
                            + parent + " (originally " + dependency.getParent() + ") " + dependency.getType() + ' ' 
                            + child + " (originally " + dependency.getParent()
                        + ") \" was not imported due to " 
                        + (null == parent ? dependency.getParent() : dependency.getChild()) + " not being resolved";
                    attachmentOM.setData(text);                    
                    issueOM.addComment(attachmentOM, ScarabUserManager.getInstance("Administrator"));
                }
                
                LOG.debug("Could not find issues: parent: " + parent + " child: " + child);
                LOG.debug("----------------------------------------------------");
                continue;
            }
            LOG.debug("doHandleDependencies: " + dependency);
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                LOG.error("[TODO] update-same-db import type not yet implemented");
                // trick here is that dependencies don't have ids or unique keys to find the 
                //  correct existing instance against.
            }
            else
            {
                try
                {
                    final String type = dependency.getType();
                    final Depend newDependOM = DependManager.getInstance();
                    final Issue parentIssueOM = IssueManager.getIssueById(parent);
                    final Issue childIssueOM = IssueManager.getIssueById(child);
                    newDependOM.setDefaultModule(parentIssueOM.getModule());
                    newDependOM.setObservedId(parentIssueOM.getIssueId());
                    newDependOM.setObserverId(childIssueOM.getIssueId());
                    newDependOM.setDependType(type);
                    LOG.debug("Dep: " + type + " Parent: " + parent + " Child: " + child);
                    LOG.debug("XML Activity id: " + activity.getId());
                    if (activity.isAddDependency())
                    {
                        parentIssueOM
                          .doAddDependency(activitySetOM, newDependOM, childIssueOM, null);
                        LOG.debug("Added Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isDeleteDependency())
                    {
                        parentIssueOM
                          .doDeleteDependency(activitySetOM, newDependOM, null);
                        LOG.debug("Deleted Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isUpdateDependency())
                    {
                        final Depend oldDependOM = parentIssueOM.getDependency(childIssueOM);
                        if (oldDependOM == null)
                        {
                            throw new IllegalArgumentException ("Whoops! Could not find the original dependency!"); //EXCEPTION
                        }
                        // we definitely know we are doing an update here.
                        newDependOM.setDeleted(false);
                        parentIssueOM
                          .doChangeDependencyType(activitySetOM, oldDependOM, newDependOM, null);
                        LOG.debug("Updated Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("Old Type: " + oldDependOM.getDependType().getName() + " New type: " + newDependOM.getDependType().getName());
                        LOG.debug("----------------------------------------------------");
                    }
                }
                catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }                
            }
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueValidateEvent(final XmlModule module, 
            final XmlIssue issue)
        throws TorqueException
    {
        // Check for the existance of the module.
        Module moduleOM = null;
        try
        {
            moduleOM = getModuleForIssue(module,issue);
            if (moduleOM == null)
            {
                throw new IllegalArgumentException(); //EXCEPTION
            }

            // TODO: Handle user import.  Until then, ignore the
            // module's owner.
            //importUsers.add(module.getOwner());
        }
        catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }

        // Check for the existance of the issue type.
        IssueType issueTypeOM = null;
        try
        {
            issueTypeOM = IssueType.getInstance(issue.getArtifactType());
            if (issueTypeOM == null)
            {
                throw new IllegalArgumentException(); //EXCEPTION
            }
            if (!moduleOM.getRModuleIssueType(issueTypeOM).getActive())
            {
                final String error = Localization.format(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueTypeInactive", issue.getArtifactType());
                importErrors.add(error);
            }
            List moduleAttributeList = null;
            if (moduleOM != null)
            {
                moduleAttributeList = moduleOM.getAttributes(issueTypeOM);
            }

            final List activitySets = issue.getActivitySets();
            for (Iterator itr = activitySets.iterator(); itr.hasNext();)
            {
                final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
                if (activitySet.getCreatedBy() != null)
                {
                    importUsers.add(activitySet.getCreatedBy());
                }
                if (activitySet.getAttachment() != null)
                {
                    final String attachCreatedBy = activitySet.getAttachment().getCreatedBy();
                    if (attachCreatedBy != null)
                    {
                        importUsers.add(attachCreatedBy);
                    }
                }

                // Validate the activity set's type.
                try
                {
                    final ActivitySetType ttOM =
                        ActivitySetTypeManager.getInstance(activitySet.getType());
                    if (ttOM == null)
                    {
                        throw new IllegalArgumentException(); //EXCEPTION
                    }
                }
                catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }

                // Validate the activity set's date.
                validateDate(activitySet.getCreatedDate(), true);

                final List activities = activitySet.getActivities();
                for (Iterator itrb = activities.iterator(); itrb.hasNext();)
                {
                    validateActivity(moduleOM, issueTypeOM, moduleAttributeList,
                                     activitySet, (XmlActivity) itrb.next());
                }
            }
        }
        catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader readerFor(Object input)
        throws IOException
    {
        if (input instanceof FileItem)
        {
            return new InputStreamReader(((FileItem) input).getInputStream());
        }
        else if (input instanceof File)
        {
            return new BufferedReader(new FileReader((File) input));
        }
        else
        {
            throw new IllegalArgumentException(); //EXCEPTION
        }
    }
0 0
(Lib) UnsupportedOperationException 19 
              
// in java/org/tigris/scarab/om/MITList.java
public void remove()
        {
            List rawList = null;
            try
            {
                rawList = getMITListItems();
            }
            catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }

            if (rawList.contains(currentObject))
            {
                rawList.remove(currentObject);
                i.remove();
                expandedList = null;
            }
            else
            {
                throw new UnsupportedOperationException(
                    "Removing items "
                        + "from a list containing wildcards is not supported."); //EXCEPTION
            }
        }
              
// in java/org/tigris/scarab/om/Query.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/Query.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/RModuleOption.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/Issue.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void save(Connection dbCon)
        throws TorqueException
    {
        Module module = getModule();
        if (!module.allowsIssues() || (isNew() && !module.allowsNewIssues())) 
        {
            throw new UnsupportedOperationException(module.getName() + 
                " does not allow issues."); //EXCEPTION
        }
        
        // remove unset AttributeValues before saving
        List attValues = getAttributeValues();
        // reverse order since removing from list
        for (int i=attValues.size()-1; i>=0; i--) 
        {
            AttributeValue attVal = (AttributeValue) attValues.get(i);
            if (!attVal.isSet()) 
            {
                attValues.remove(i);
            }
        }

        if (isNew())
        {
            // set the issue id
            setIdDomain(module.getScarabInstanceId());
            setIdPrefix(module.getCode());

            // for an enter issue template, do not give issue id
            // set id count to -1 so does not show up as an issue
            if (isTemplate())
            { 
                setIdCount(-1);
            }
            else
            {
                try
                {
                    final int suggestedID = getIdCount();
                    if (suggestedID != 0) {
                        // Force the next available issue ID to be the
                        // nominated value, if not out of sequence.
                        // TODO: assert that this issue doesn't already exist
                        // In this case, just skip the next action.
                        setNextIssueId(dbCon, suggestedID);
                    }
                    
                    // Set the ID to the next available value.
                    setIdCount(getNextIssueId(dbCon));
                }
                catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        if(  getActivitySetRelatedByLastTransId()==null
           ||getActivitySetRelatedByCreatedTransId()==null)
        {
            throw new RuntimeException("Created or Last ActivitySet must not be null.");
        }
        super.save(dbCon);
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void save()
    {
        throw new UnsupportedOperationException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void save(String dbName)
    {
        throw new UnsupportedOperationException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void save(Connection dbCon)
    {
        throw new UnsupportedOperationException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/AttributeGroup.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
public Map getMapImpl()
    {
        throw new UnsupportedOperationException(
        "'getMap' is not implemented");
    }
              
// in java/org/tigris/scarab/util/WindowIterator.java
public void remove()
    {
        throw new UnsupportedOperationException("'remove' is not implemented"); //EXCEPTION
    }
0 0
(Lib) Exception 12 
              
// in java/org/tigris/scarab/screens/RSSDataExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
			throws Exception {
		super.doBuildTemplate(data, context);

		data.getResponse().setContentType(MIME_TYPE);

		// we will send the response, so no target to render
		data.setTarget(null);
		
		Writer writer = data.getResponse().getWriter();
		
		try {
            ParameterParser parser = data.getParameters();



            String feedType = parser.getString(FEED_TYPE_KEY);
            if(feedType == null)
            {
                String msg = COULD_NOT_FIND_FEED_TYPE;
                Log.get().error(msg);
                data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);            
                return;
            }

            String feedFormat = parser.getString(FEED_FORMAT_KEY);

            ScarabLink scarabLink= getScarabLinkTool(context);
            
            Feed feedSource = null;
            if (feedType.equals("IssueFeed")){
                String issueId = parser.getString(ISSUE_ID_KEY);                
                if(issueId.equals("")){
                    throw new IllegalArgumentException("Issue ID is missing.  Should be appended like: /issueId/xxx");
                }            	
            	Issue issue = IssueManager.getIssueById(issueId);
            	feedSource = new IssueFeed(issue,scarabLink, getLocalizationTool(context));
            }
            else {
            	throw new Exception("Couldn't find feed for type:" + feedType);
            }
            SyndFeed feed = feedSource.getFeed();

            feedFormat = (feedFormat!=null) ? feedFormat : DEFAULT_FEED_FORMAT;
            feed.setFeedType(feedFormat);

            
            SyndFeedOutput output = new SyndFeedOutput();
            output.output(feed,writer);
        }
        catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }        
        catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }      		
	}
              
// in java/org/tigris/scarab/actions/TemplateList.java
public void doDeletetemplates(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Object[] keys = data.getParameters().getKeys();
        String key;
        String templateId;
        ScarabUser user = (ScarabUser)data.getUser();
        boolean atLeastOne = false;
        boolean success = true;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
                atLeastOne = true;
                templateId = key.substring(7);
                try
                {
                    Issue issue = IssueManager
                       .getInstance(new NumberKey(templateId), false);
                    if (issue == null)
                    {
                        throw new Exception(
                            l10n.get("CouldNotLocateTemplateToDelete")); //EXCEPTION
                    }
                    issue.deleteItem(user);
                }
                catch (ScarabException e)
                {
                    success = false;
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
                catch (Exception e)
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.getMessage(e));
                }
            }
        } 
        if (!atLeastOne)
        {
            scarabR.setAlertMessage(L10NKeySet.NoTemplateSelected);
        }
        else if (success)
        {
            scarabR.setConfirmMessage(L10NKeySet.TemplateDeleted);
        } 
    }
              
// in java/org/tigris/scarab/actions/ModifyModule.java
public void doUpdate(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        if (intake.isAllValid())
        {
            Module me = null;
            try
            {
                me = scarabR.getModule();
            }
            catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }

            Group moduleGroup = intake.get
                ("Module",me.getQueryKey(), false);

            if (moduleGroup == null)
            {
                setTarget(data, template);
                scarabR.setAlertMessage(
                    L10NKeySet.CouldNotLocateModuleGroup);
                return;
            }
            else
            {
                ScarabUser user = (ScarabUser) data.getUser();

                // make sure that the user has Edit permission 
                // in the module.
                if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, me))
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                    intake.remove(moduleGroup);
                    setTarget(data, nextTemplate);
                    return;
                }

                Module origParent = me.getParent();
                String origCode = me.getCode();
                moduleGroup.setProperties(me);
                Module newParent = me.getParent();
                String newCode = me.getCode();

                if (newParent.getParent() == me && origParent!=me)
                {
                    scarabR.setAlertMessage(L10NKeySet.CircularParentChildRelationship);
                    intake.remove(moduleGroup);
                    setTarget(data, template);
                    return;
                }
                else if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, origParent) && 
                    origParent.getModuleId() != newParent.getModuleId())
                {
                    scarabR.setAlertMessage(L10NKeySet.NoPermissionInParentModule);
                    setTarget(data, template);
                    return;
                }
                
                // Cascade update the code to the (denormalized) issue prefix
                if (! newCode.equals(origCode))
                {
                    if (me instanceof ScarabModule)
                    {
                        ScarabModule sm = (ScarabModule)me;
                        List issues = sm.getIssues();
                        for (int i = 0; i < issues.size(); i++)
                        {
                            Issue issue = (Issue)issues.get(i);
                            if (! issue.getIdPrefix().equals(me.getCode()))
                            {
                                issue.setIdPrefix(me.getCode());
                                issue.save();
                            }
                        }
                        //Update the ID table to reflect the module code r
                        // FIXME: Using SQL because IDBroker doesn't have a Peer yet.
                        String idTable = IDBroker.TABLE_NAME.substring(0, 
                                IDBroker.TABLE_NAME.indexOf('.'));
                        String instanceId = GlobalParameterManager
                        .getString(ScarabConstants.INSTANCE_ID);
                        String sql = "update " + idTable 
                         + " SET TABLE_NAME='" + instanceId + "-" + newCode + "' WHERE TABLE_NAME='" +
                         instanceId + "-" + origCode + "'";
                        BasePeer.executeStatement(sql);                                                
                    }
                    else
                    {
                        throw new Exception ("Did not get a ScarabModule"); //EXCEPTION
                    }
                }
                
                me.save();

                updateModuleParameters(data, me);
                
                intake.remove(moduleGroup);
                setTarget(data, nextTemplate);
                scarabR.setConfirmMessage(L10NKeySet.ModuleUpdated);
            }
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyModule.java
public void doCreate(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        if (intake.isAllValid())
        {
            Group moduleGroup = intake.get
                ("Module",IntakeTool.DEFAULT_KEY, false);
            Module me = ModuleManager.getInstance();
            if (moduleGroup == null)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
            moduleGroup.setProperties(me);
            ScarabUser user = (ScarabUser)data.getUser();
            
            // make sure that the user has Edit permission 
            // in the parent module.
            if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, 
                me.getParent()))
            {
                scarabR.setAlertMessage(L10NKeySet.NoPermissionInParentModule);
            }
            else
            {
            	try{
	                me.setOwnerId(user.getUserId());
	                me.save();
	                
	                updateModuleParameters(data, me);
	
	                data.setACL(((ScarabUser)data.getUser()).getACL());
	                data.save();
	
	                scarabR.setConfirmMessage(L10NKeySet.NewModuleCreated);
	                intake.remove(moduleGroup);
            	}
                catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
            }
        }
        else
        {
            setTarget(data, template);
            return;
        }
        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
private void setRequiredFlags(Issue issue, IntakeTool intake,
    		LinkedMap avMap, TemplateContext context)
        throws Exception
    {
        if (issue == null)
        {
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            throw new Exception(l10n.get("IssueNoLongerValid")); //EXCEPTION
        }
        Set selectedOptions = new HashSet();
        Map conditionallyRequiredFields = new HashMap(); 
        IssueType issueType = issue.getIssueType();
        List requiredAttributes = issueType
            .getRequiredAttributes(issue.getModule());
        for (MapIterator iter = avMap.mapIterator(); iter.hasNext();)
        {
            AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            
            Group group = 
                intake.get("AttributeValue", aval.getQueryKey(), false);
            if (group != null) 
            {            
                Field field = null;
                if (aval instanceof OptionAttribute) 
                {
                    field = group.get("OptionId");
                    // Will store the selected optionId, for later query.
                    Object fieldValue = field.getValue();
                    if (null != fieldValue)
                    {
                        selectedOptions.add(fieldValue);
                    }                    
                }
                else if (aval instanceof IntegerAttribute) 
                {
                    field = group.get("NumericValue");
                }
                else if (aval instanceof UserAttribute) 
                {
                    field = group.get("UserId");
                }
                else 
                {
                    field = group.get("Value");
                }

                /**
                 * If the field has any conditional constraint, will be added to the collection
                 * in the hash.
                 */ 
                List conditions = aval.getRModuleAttribute().getConditions(); 
                if (conditions.size() > 0)
                {
                    for (Iterator it = conditions.iterator(); it.hasNext(); )
                    {
                        Condition cond = (Condition)it.next();
                        Integer id = cond.getOptionId();
                        List fields = (List)conditionallyRequiredFields.get(id);
                        if (fields == null)
                        {
                            fields = new ArrayList();
                        }
                        fields.add(field);
                        conditionallyRequiredFields.put(id, fields);
                    }
                }                
                
                for (int j=requiredAttributes.size()-1; j>=0; j--) 
                {
                    if (aval.getAttribute().getPrimaryKey().equals(
                            ((Attribute)requiredAttributes.get(j)).getPrimaryKey())
                        && !aval.isSet())
                    {
                        field.setRequired(true);
                        break;
                    }                    
                }
            }
        }
        /**
         * Now that we have all the info, we will force the 'required' status of any field
         * whose requiredOptionId has been set in the issue.
         */
        for (Iterator requiredIds = conditionallyRequiredFields.keySet().iterator(); requiredIds.hasNext(); )
        {
            Integer attributeId= (Integer)requiredIds.next();
            if (selectedOptions.contains(attributeId))
            {
                List fields = (List)conditionallyRequiredFields.get(attributeId);
                for (Iterator iter = fields.iterator(); iter.hasNext(); )
                {
                    Field field = (Field)iter.next();
            	    if (field.getValue().toString().length() == 0)
            	    {
            	       field.setRequired(true);
            	       field.setMessage("ConditionallyRequiredAttribute");
            	    }
                }
            }
        }        
    }
              
// in java/org/tigris/scarab/actions/admin/AppConfigurationSettings.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        boolean customSettingsChanged = false;
        ParameterParser pp = data.getParameters();
        CompositeConfiguration c = (CompositeConfiguration)Turbine.getConfiguration();
        PropertiesConfiguration customSettings =null;
        for (int i = 0;i<c.getNumberOfConfigurations();i++){
            if(c.getConfiguration(i) instanceof PropertiesConfiguration){
                PropertiesConfiguration pc = (PropertiesConfiguration)c.getConfiguration(i);
                if(pc.getFileName().endsWith("custom.properties")){
                    customSettings = pc;
                    break;
                }
            }
        }
 
        if (customSettings==null){
            throw new Exception("custom.properties file was not defined in TurbineConfiguration.xml");
        }
                
        for (Iterator i =
            IteratorUtils.filteredIterator(
                new EnumerationIterator(pp.keys()),
                new StartsWithPredicate("configuration.key."));
            i.hasNext();
            )
        {
            String key = (String) i.next();
            String realKey = pp.getString(key);
            String value = pp.getString("configuration.value." + realKey);
            
            String turbineValue;
            try
            {
            	turbineValue = Turbine.getConfiguration().getString(realKey);
            }
            catch( ConversionException ce)
            {
            	// This happens, if the Turbine Property is not a String.
            	// This has been seen on JBOSS. Since we can't provide any
            	// reasonable value here, ignore the entry and continue.
            	log.warn("Turbine property ["+realKey+"] is not a String value. No update done. (continue)");
            	turbineValue = null;
            }            
            
            if (turbineValue != null && !turbineValue.equals(value))
            {
                Turbine.getConfiguration().setProperty(realKey,value);                
                customSettings.setProperty(realKey,value);
                customSettingsChanged=true;                
            }
            
        }
        if (customSettingsChanged){
            customSettings.save();
        }
        
        
        getScarabRequestTool(context).setConfirmMessage(L10NKeySet.AppConfigurationChangesSaved);
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void validateActivity(final Module moduleOM, 
            final IssueType issueTypeOM,
            final List moduleAttributeList,
            final XmlActivitySet activitySet,
            final XmlActivity activity)
    {
        validateDate(activity.getEndDate(), false);
        if (activity.getOldUser() != null)
        {
            importUsers.add(activity.getOldUser());
        }
        if (activity.getNewUser() != null)
        {
            importUsers.add(activity.getNewUser());
        }
        final XmlAttachment activityAttachment = activity.getAttachment();
        if (activityAttachment != null)
        {
            if (allowFileAttachments &&
                activityAttachment.getReconcilePath() &&
                !new File(activityAttachment.getFilename()).exists())
            {
                final String error = Localization.format
                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                     "CouldNotFindFileAttachment",
                     activityAttachment.getFilename());
                importErrors.add(error);
            }

            validateDate(activityAttachment.getCreatedDate(), true);
            validateDate(activityAttachment.getModifiedDate(), false);

            final String attachCreatedBy = activityAttachment.getCreatedBy();
            if (attachCreatedBy != null)
            {
                importUsers.add(attachCreatedBy);
            }
        }

        // Get the Attribute associated with the Activity
        Attribute attributeOM = null;
        final String activityAttribute = activity.getAttribute();
        try
        {
            attributeOM = Attribute.getInstance(activityAttribute);
            if (attributeOM == null)
            {
                throw new Exception(); //EXCEPTION
            }
        }
        catch (Exception e)
        {
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "CouldNotFindGlobalAttribute", activityAttribute);
            importErrors.add(error);
        }

        if (attributeOM != null)
        {
            if (attributeOM.equals(nullAttribute))
            {
                // Add any dependency activities to a list for later
                // processing.
                if (isDependencyActivity(activity))
                {
                    if (!isDuplicateDependency(activity))
                    {
                        allDependencies.add(activity);
                        LOG.debug("+------------Stored Dependency # " +
                                  allDependencies.size() + '[' + activity.getDependency() + ']');
                    }

                    // Dependency activities don't require further
                    // validation.
                    return;
                }
            }
            else 
                try 
                {
                    if( !attributeOM.isUserAttribute() )
                    {
                        // The null attribute will never be in this list.
                        if (moduleAttributeList != null &&
                            moduleAttributeList.indexOf(attributeOM) < 0)
                        {
                            final String error = Localization.format
                                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                 "CouldNotFindRModuleAttribute", activityAttribute);
                            importErrors.add(error);
                        }
                        else if (activity.getNewOption() != null)
                        {
                            // check for global options
                            AttributeOption attributeOptionOM = null;
                            try
                            {
                                attributeOptionOM = AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                                if (attributeOptionOM == null)
                                {
                                    throw new Exception(); //EXCEPTION
                                }
                            }
                            catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
                            // check for module options
                            try
                            {
                                final RModuleOption rmo = RModuleOptionManager
                                    .getInstance(moduleOM, issueTypeOM,
                                                 attributeOptionOM);
                                if (rmo == null)
                                {
                                    throw new Exception(); //EXCEPTION
                                }
                            }
                            catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
                        }
                        else if (activity.getOldOption() != null)
                        {
                            AttributeOption attributeOptionOM = null;
                            try
                            {
                                attributeOptionOM = AttributeOptionManager
                                    .getInstance(attributeOM, activity.getOldOption());
                                if (attributeOptionOM == null)
                                {
                                    throw new Exception(); //EXCEPTION
                                }
                            }
                            catch (Exception e)
                            {
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption",
                                     activity.getOldOption());
                                importErrors.add(error);
                            }
                            // check for module options
                            try
                            {
                                final RModuleOption rmo = RModuleOptionManager
                                    .getInstance(moduleOM, issueTypeOM,
                                                 attributeOptionOM);
                                if (rmo == null)
                                {
                                    throw new Exception(); //EXCEPTION
                                }
                            }
                            catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
                        }
                    }
                } 
                catch (TorqueException ex) 
                {
                    ex.printStackTrace();
                    importErrors.add(ex);
                }
        }
    }
1
              
// in java/org/tigris/scarab/actions/ModifyModule.java
catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
525
              
// in java/org/tigris/scarab/pipeline/AnonymousLoginValve.java
public void initialize() throws Exception
    {
        anonymousAccessAllowed = ScarabUserManager.anonymousAccessAllowed();
        if (anonymousAccessAllowed) {
            Log.get().info("anonymous Login enabled.");
	        nonAnonymousTargets.add("Register.vm");
	        nonAnonymousTargets.add("ForgotPassword.vm");
        }
        else
        {
            Log.get().info("anonymous Login disabled.");
        }
    }
              
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve22.java
public void initialize() throws Exception{
        super.initialize();
        REQUIRED_CHARSET = Turbine.getConfiguration().
        getString("locale.default.charset",null);
    }
              
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve.java
public void initialize() throws Exception{
        super.initialize();
        REQUIRED_CHARSET = Turbine.getConfiguration().
        getString("locale.default.charset",null);
    }
              
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
public void initialize() throws Exception{
        super.initialize();
        KEY = TimingInfoValve.class.getName() + ".start";

    }
              
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
private void storePreferredLocale(ScarabUser user, String localeAsString)
        throws Exception
    {
    	// Change the settings in the database
        UserPreference pref =
            UserPreferenceManager.getInstance(user.getUserId());
        pref.setLocale(localeAsString);
        pref.save();

        // The internal user caches the current locale,
        // hence we need to modify the user's locale now.
		Locale locale = Localization.getLocale(localeAsString);
        user.setLocale(locale);
    }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
public void initialize() throws Exception {
        XMIT_SCREENS.put("IssueTypeList.vm", null);
        XMIT_SCREENS.put("AdvancedQuery.vm", null);
        XMIT_SCREENS.put("Search.vm", null);
        XMIT_SCREENS.put("IssueList.vm", null);
        XMIT_SCREENS.put("RSSDataExport.vm", null);
        XMIT_SCREENS.put("RSSIssueList.vm", null);
        XMIT_SCREENS.put("ViewIssue.vm", null);
        XMIT_SCREENS.put("QueryList.vm", null);
        XMIT_SCREENS.put("SaveQuery.vm", null);
        XMIT_SCREENS.put("EditQuery.vm", null);
        XMIT_SCREENS.put("UserList.vm", null);
        XMIT_SCREENS.put("ConfigureIssueList.vm", null);
        XMIT_SCREENS.put("EditXModuleList.vm", null);
        XMIT_SCREENS.put("reports,Info.vm", null);
        XMIT_SCREENS.put("reports,ConfineDataset.vm", null);
        XMIT_SCREENS.put("reports,XModuleList.vm", null);
        XMIT_SCREENS.put("reports,AxisConfiguration.vm", null);
        XMIT_SCREENS.put("reports,Report_1.vm", null);
        // this is not a real .vm file, but a pointer to a java screen class
        XMIT_SCREENS.put("IssueListExport.vm", null);
        
    }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentModule(ScarabUser user, RunData data)
        throws TurbineException, Exception
    {
        Module module = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_MODULE);
        if (key != null) 
        {
            try
            {
                module = ModuleManager.getInstance(new Integer(key));
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else if (parameters.getString("id") != null) 
        {
            try  
            {
                module = IssueManager.getIssueById(parameters.getString("id")).getModule();
                parameters.setString(ScarabConstants.CURRENT_MODULE, 
                             module.getQueryKey());
            }
            catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
        }
        if(module!=null)
        {
            user.setCurrentModule(module);
        }
    }
              
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
public void initialize() throws Exception
    {
        bNTLMActive = Turbine.getConfiguration().getBoolean("scarab.login.ntlm.active", false);
        domainController = Turbine.getConfiguration().getString("scarab.login.ntlm.domain", "<check properties>");
        Config.setProperty("jcifs.util.loglevel", log.isDebugEnabled()?"10":"0");        
        Config.setProperty("jcifs.smb.client.soTimeout", "300000");
        Config.setProperty("jcifs.netbios.cachePolicy", "600");
        Config.setProperty("jcifs.http.domainController", domainController);
        Config.setProperty("jcifs.smb.client.domain", domainController);
        Config.setProperty("http.auth.ntlm.domain", domainController);        

        if( domainController == null )
        {
            bNTLMActive = false;
            Log.get(this.getClass().getName()).debug("Domain controller must be specified.");
        }
        super.initialize();
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeOption getAttributeOption()
        throws Exception
    {
        if (attributeOption == null)
        {
            String optId = getIntakeTool()
                .get("AttributeOption", IntakeTool.DEFAULT_KEY)
                .get("OptionId").toString();
            if (optId == null || optId.length() == 0)
            {
                attributeOption = AttributeOptionManager.getInstance();
            }
            else
            {
                attributeOption = AttributeOptionManager
                    .getInstance(new Integer(optId));
            }
        }
        return attributeOption;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Attribute getAttribute()
        throws Exception
    {
        try
        {
            if (attribute == null)
            {
                String attId = getIntakeTool()
                    .get("Attribute", IntakeTool.DEFAULT_KEY)
                    .get("Id").toString();
                if (attId == null || attId.length() == 0)
                {
                    attId = data.getParameters().getString("attId");
                    if (attId == null || attId.length() == 0)
                    {
                        attribute = AttributeManager.getInstance();
                    }
                    else
                    {
                        attribute = AttributeManager.getInstance(new Integer(attId));
                    }
                }
                else
                {
                    attribute = AttributeManager.getInstance(new Integer(attId));
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return attribute;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Attribute getAttribute(Integer attrId)
     throws Exception
    {
        this.attribute = AttributeManager.getInstance(attrId);
        return this.attribute;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeOption getAttributeOption(Integer pk)
     throws Exception
    {
        try
        {
           attributeOption = AttributeOptionManager.getInstance(pk);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return attributeOption;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeOption getAttributeOption(String key)
         throws Exception
    {
        return getAttributeOption(new Integer(key));
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueTemplateInfo getIssueTemplateInfo()
        throws Exception
    {
        try
        {
            if (templateInfo == null)
            {
                String templateId = data.getParameters()
                    .getString("templateId");

                if (templateId == null || templateId.length() == 0)
                {
                    templateInfo = IssueTemplateInfo.getInstance();
                }
                else
                {
                    templateInfo = IssueTemplateInfoManager
                        .getInstance(new NumberKey(templateId), false);
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return templateInfo;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Issue getIssueTemplate()
     throws Exception
    {
        Issue template = null;
        String templateId = data.getParameters()
            .getString("templateId");
        try
        {
            if (templateId == null || templateId.length() == 0)
            {
                IssueType issueType = getCurrentIssueType();
                Integer templateID  = issueType.getTemplateId();
                if(templateID.intValue()!=0)
                {
                    IssueType finalIssueType = getIssueType(templateID.toString());
                    template = getCurrentModule().getNewIssue(finalIssueType);
                }
            }
            else
            {
                template = IssueManager
                    .getInstance(new NumberKey(templateId), false);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return template;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Issue getIssueTemplate(String templateId)
        throws Exception
    {
        Issue template = null;
        try
        {
            if (templateId == null || templateId.length() == 0)
            {
                setAlertMessage(L10NKeySet.NoTemplateId);
            }
            else
            {
                template = IssueManager
                    .getInstance(new NumberKey(templateId), false);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return template;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Depend getDepend()
     throws Exception
    {
        try
        {
            if (depend == null)
            {
                String dependId = getIntakeTool()
                    .get("Depend", IntakeTool.DEFAULT_KEY).get("Id").toString();
                if (dependId == null || dependId.length() == 0)
                {
                    depend = DependManager.getInstance();
                }
                else
                {
                    depend = DependManager
                        .getInstance(new NumberKey(dependId), false);
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return depend;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Attachment getAttachment()
        throws Exception
    {
		try
		{
	        if (attachment == null)
	        {
	            Group att = getIntakeTool()
	                .get("Attachment", IntakeTool.DEFAULT_KEY, false);
	            if (att != null)
	            {
	                String attId =  att.get("Id").toString();
	                if (attId == null || attId.length() == 0)
	                {
	                    attachment = new Attachment();
	                }
	                else
	                {
	                    attachment = AttachmentManager
	                        .getInstance(new NumberKey(attId), false);
	                }
	            }
	            else
	            {
	                attachment = new Attachment();
	            }
	        }
		}
		catch(Exception e)
		{
		e.printStackTrace(); throw e; //EXCEPTION
		}
        return attachment;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeGroup getAttributeGroup()
        throws Exception
    {
        AttributeGroup group = null;
        try
        {
            String attGroupId = getIntakeTool()
                .get("AttributeGroup", IntakeTool.DEFAULT_KEY)
                .get("AttributeGroupId").toString();
            if (attGroupId == null || attGroupId.length() == 0)
            {
                group = new AttributeGroup();
            }
            else
            {
                group = AttributeGroupManager.getInstance(new NumberKey(attGroupId), false);
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return group;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeValue getNewAttributeValue(Attribute attribute, Issue issue)
        throws Exception
    {

        return AttributeValue.getNewInstance(attribute.getAttributeId(),issue);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public RModuleAttribute getRModuleAttribute()
        throws Exception
    {
        RModuleAttribute rma = null;
        try
        {
            ComboKey rModAttId = (ComboKey)getIntakeTool()
                .get("RModuleAttribute", IntakeTool.DEFAULT_KEY)
                .get("Id").getValue();
            if (rModAttId == null)
            {
                Integer attId = (Integer)getIntakeTool()
                    .get("Attribute", IntakeTool.DEFAULT_KEY)
                    .get("Id").getValue();
                Module currentModule = getCurrentModule();
                if (attId != null && currentModule != null)
                {
                    SimpleKey[] nka = {
                        SimpleKey.keyFor(attId),
                        SimpleKey.keyFor(currentModule.getModuleId())
                    };
                    rma = RModuleAttributeManager
                        .getInstance(new ComboKey(nka), false);
                }
                else
                {
                    rma = new RModuleAttribute();
                }
            }
            else
            {
                rma = RModuleAttributeManager.getInstance(rModAttId, false);
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return rma;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Issue getReportingIssue()
        throws Exception
    {
        if (reportingIssue == null)
        {
            String key = data.getParameters()
                .getString(ScarabConstants.REPORTING_ISSUE);

            if (key == null)
            {
                getNewReportingIssue();
            }
            else
            {
                reportingIssue = ((ScarabUser)data.getUser())
                    .getReportingIssue(key);

                // if reportingIssue is still null, the parameter must have
                // been stale, just get a new issue
                if (reportingIssue == null)
                {
                    getNewReportingIssue();
                }
            }
        }
        return reportingIssue;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private void getNewReportingIssue()
        throws Exception
    {
        IssueType currentIssueType = getCurrentIssueType();
        if (currentIssueType != null)
        {
            Module currentModule = getCurrentModule();
            if(currentModule != null)
            {
                reportingIssue = currentModule.getNewIssue(currentIssueType);
                String key = ((ScarabUser)data.getUser())
                    .setReportingIssue(reportingIssue);
                data.getParameters().add(ScarabConstants.REPORTING_ISSUE, key);
            }
        }
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Issue getIssue()
        throws Exception
    {
        if (issue == null)
        {
            String issueId = null;
            Group issueGroup = getIntakeTool()
                .get("Issue", IntakeTool.DEFAULT_KEY, false);
            if (issueGroup != null)
            {
                issueId =  issueGroup.get("Id").toString();
            }
            else
            {
                issueId = data.getParameters().getString("id");
            }
            if (issueId != null && issueId.length() > 0)
            {
                issue = getIssue(issueId);
            }
        }
        return issue;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getIssues()
        throws Exception
    {
        List issues = null;

        Group issueGroup = getIntakeTool()
            .get("Issue", IntakeTool.DEFAULT_KEY, false);
        if (issueGroup != null)
        {
            Long[] issueIds =  (Long []) issueGroup.get("Ids").getValue();
            if (issueIds != null)
            {
                issues = getIssues(Arrays.asList(issueIds));
            }
        }
        else
        {
            String[] paramIssueIds = data.getParameters().getStrings("issue_ids");
            if (paramIssueIds != null)
            {
                issues = getIssues(Arrays.asList(paramIssueIds));
            }
        }
        if (issues == null)
        {
            issues = Collections.EMPTY_LIST;
        }
        return issues;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getIssues(List issueIds)
        throws Exception
    {
        List issues = null;
        StringBuffer invalidIds = null;
        if (issueIds == null || issueIds.isEmpty())
        {
            issues = Collections.EMPTY_LIST;
        }
        else
        {
            if (issueIds.get(0) instanceof String)
            {
                issues = new ArrayList(issueIds.size());
                Iterator i = issueIds.iterator();
                while (i.hasNext())
                {
                    String id = (String)i.next();
                    Issue issue = getIssue(id);
                    if (issue == null)
                    {
                        if (invalidIds == null)
                        {
                            invalidIds = new StringBuffer(id);
                        }
                        else
                        {
                            invalidIds.append(' ').append(id);
                        }
                    }
                    else
                    {
                        issues.add(issue);
                    }
                }
                if (invalidIds != null)
                {
                    setAlertMessage(getLocalizationTool()
                        .format("SomeIssueIdsNotValid", invalidIds.toString()));
                }
            }
            else if (issueIds.get(0) instanceof Long)
            {
                issues = new ArrayList(issueIds.size());
                Iterator i = issueIds.iterator();
                while (i.hasNext())
                {
                    Issue issue = IssueManager.getInstance((Long)i.next());
                    if (issue == null)
                    {
                        setAlertMessage(L10NKeySet.SomeIssuePKsNotValid);
                    }
                    else
                    {
                        issues.add(issue);
                    }
                }
            }
            else
            {
                throw new IllegalArgumentException(
                    "issue ids must be Strings or Longs, not " +
                    issueIds.get(0).getClass().getName()); //EXCEPTION
            }
        }
        return issues;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getScopes()
        throws Exception
    {
        return ScopePeer.getAllScopes();
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getFrequencies()
        throws Exception
    {
        return FrequencyPeer.getFrequencies();
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Intake getConditionalIntake(String parameter)
        throws Exception
    {
        Intake intake = null;
        String param = data.getParameters().getString(parameter);
        if (param == null)
        {
            intake = getIntakeTool();
        }
        else
        {
            StringValueParser parser = ScarabUtil.parseURL(param);
            intake = new Intake();
            intake.init(parser);
        }

        return intake;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private IssueSearch getPopulatedSearch(String queryString)
        throws Exception
    {
        IssueSearch search = getNewSearch();
        Query theQuery = this.getQuery();

        search.setLocale(getLocalizationTool().getPrimaryLocale());
        search.setIssueListAttributeColumns(getRModuleUserAttributes(theQuery));
        search.setLocalizationTool(getLocalizationTool());

        StringValueParser parser = ScarabUtil.parseURL(queryString);

        String[] userList = parser.getStrings("user_list");
        boolean searchInAllAttributes = parser.getBoolean("searchallattributes",false);
        if (userList != null && userList.length > 0)
        {
            for (int i = 0; i < userList.length; i++)
            {
                String userId = userList[i];
                String[] attrIds = parser.getStrings("user_attr_" + userId);
                if (attrIds != null)
                {
                    for (int j = 0; j < attrIds.length; j++)
                    {
                        search.addUserSearch(userId, attrIds[j]);
                    }
                }
            }
        }

        Intake intake = new Intake();
        intake.init(parser);
        Group searchGroup = intake.get("SearchIssue", search.getQueryKey());

        boolean datesValid = true;
        Field minCreationDate = searchGroup.get("MinCreationDate");
        if (minCreationDate!= null && minCreationDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, minCreationDate);
        }

        Field maxCreationDate = searchGroup.get("MaxCreationDate");
        if (maxCreationDate != null && maxCreationDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, maxCreationDate);
        }

        Field minChangeDate = searchGroup.get("MinChangeDate");
        if (minChangeDate != null && minChangeDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, minChangeDate);
        }

        Field maxChangeDate = searchGroup.get("MaxChangeDate");
        if (maxChangeDate != null && maxChangeDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, maxChangeDate);
        }

        Field stateChangeFromDate = searchGroup.get("StateChangeFromDate");
        if (stateChangeFromDate != null
            && stateChangeFromDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, stateChangeFromDate);
        }

        Field stateChangeToDate = searchGroup.get("StateChangeToDate");
        if (stateChangeToDate != null
            && stateChangeToDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, stateChangeToDate);
        }

        if (!datesValid)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.DateFormatPrompt,L10NKeySet.ShortDateDisplay);
            setAlertMessage(msg);
            return null;
        }

        searchGroup.setProperties(search);

        // Set attribute values to search on
        Map avMap = search.getAttributeValuesMap(!searchInAllAttributes);

        for(Iterator i = avMap.values().iterator();i.hasNext();)
        {
            AttributeValue aval = (AttributeValue)i.next();

            Group group = intake.get("AttributeValue", aval.getQueryKey());

            if (group!=null)
            {
                group.setProperties(aval);
            }

            if(aval instanceof DateAttribute)
            {
                String auxDate = parser.getString("attv__" + aval.getAttributeId().intValue() + "val_aux");

                if (auxDate != null)
                {
                	AttributeValue auxAval = AttributeValue.getNewInstance(aval.getAttribute(), aval.getIssue());
                	auxAval.setValue(auxDate);
                	aval.setChainedValue(auxAval);
                }
            }
        }

        String sortColumn = data.getParameters().getString("sortColumn");
        if(isValidIssueSearchSortColumn(sortColumn))
        {
            search.setSortAttributeId( Integer.valueOf(sortColumn) );
        }
        search.setSortInternalAttribute(data.getParameters().getString("sortInternal"));
        search.setSortPolarity(data.getParameters().getString("sortPolarity"));

        return search;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueSearch getNewSearch() throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        MITList mitList = user.getCurrentMITList();
        IssueSearch search = IssueSearchFactory.INSTANCE.getInstance(mitList, user);
        return search;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueSearch getPopulatedSearch()
        throws Exception
    {
        String currentQueryString = ((ScarabUser)data.getUser()).getMostRecentQuery();
        return getPopulatedSearch(currentQueryString);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private List getUnprotectedCurrentSearchResults()
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();

		// [HD] Very experimental: The following code allows to create a shortLink
		// to a public or private query similar to what has been implemented
		// as shortLink for Issues. The URL-syntax is:
		//
        // <scarabHost>/scarab/issues/query/<queryId>
        // 
        // The queryId should be sufficient to setup the full query.
        // But i have seen a problem, when the user has only limitted
        // module read permissions. In that case the LoginValve
        // forces a login before the query can be perfromed.
        // Workaround: Also add the moduleId to the URL:
        //
        // <scarabHost>/scarab/issues/query/<queryId>/curmodule/<moduleId>
        // 
        // The current solution always uses the default MITList, hence it will
        // not take care of user customized resultsets. 
        // I am not sure, where to place this code and how to actually
        // control the search-Subsystem so that it will perfrom the correct
        // search. Any help and advice for a better solution is heavily welcome!!!
		
        String currentQueryString = user.getMostRecentQuery();
        String sortColumn = data.getParameters().getString("sortColumn");
        String sortInternal=data.getParameters().getString("sortInternal");
        String sortPolarity = data.getParameters().getString("sortPolarity");
        String currentQueryAddition = "" + sortColumn + sortInternal + sortPolarity;
        String cachedQueryAddition = (String)data.getUser().getTemp("queryAddition");

        List queryResult = (List)data.getUser().getTemp("queryResult");

        if (cachedQueryAddition==null || !cachedQueryAddition.equals(currentQueryAddition) || queryResult==null)
        {
            // currentQueryString gets lost if the session timed out. an empty search result is returned then.
            queryResult = null != currentQueryString
                    ? getSearchResults(currentQueryString)
                    : Collections.emptyList();

            data.getUser().setTemp("queryAddition", currentQueryAddition );
            data.getUser().setTemp("queryResult", queryResult);
        }

        return queryResult;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private List getSearchResults(String queryString)
        throws Exception
    {
        IssueSearch search = getPopulatedSearch(queryString);

        if(null != search)
        {
            return search.getQueryResults();	
        }

        return new ArrayList(); //why not Collections.EMPTY_LIST ?
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String convertPath(String path)
        throws Exception
    {
            return path.replace('/',',');
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getAllIssueTemplates(IssueType issueType)
        throws Exception
    {
        List result;
        if(issueType == null)
        {
            Log.get().warn("Can not retrieve IssueTemplates for issueType NULL. Return empty List.");
            result = Collections.EMPTY_LIST;
        }
        else
        {
            ParameterParser params = data.getParameters();
            String sortColumn = params.getString("sortColumn", "name");
            String sortPolarity = params.getString("sortPolarity", "asc");
            result = IssueTemplateInfoPeer.getTemplates(getCurrentModule(),
               issueType, (ScarabUser)data.getUser(),
               sortColumn, sortPolarity, IssueTemplateInfoPeer.TYPE_ALL);
        }
        return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getPrivateTemplates(IssueType issueType)
        throws Exception
    {
        return IssueTemplateInfoPeer.getTemplates(getCurrentModule(),
               issueType, (ScarabUser)data.getUser(),
               "name", "asc", IssueTemplateInfoPeer.TYPE_PRIVATE);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getGlobalTemplates(IssueType issueType)
        throws Exception
    {
        return IssueTemplateInfoPeer.getTemplates(getCurrentModule(),
               issueType, (ScarabUser)data.getUser(),
               "name", "asc", IssueTemplateInfoPeer.TYPE_GLOBAL);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getAllQueries()
        throws Exception
    {
        String sortColumn = data.getParameters().getString("sortColumn");
        String sortPolarity = data.getParameters().getString("sortPolarity");
        if (sortColumn == null)
        {
            sortColumn = "avail";
        }
        if (sortPolarity == null)
        {
            sortPolarity = "desc";
        }
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               sortColumn, sortPolarity, IssueTemplateInfoPeer.TYPE_ALL);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getPrivateQueries()
        throws Exception
    {
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               "name", "asc", QueryPeer.TYPE_PRIVATE);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getUserQueries()
        throws Exception
    {
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               "name", "asc", QueryPeer.TYPE_ALL_USER);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getGlobalQueries()
        throws Exception
    {
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               "name", "asc", QueryPeer.TYPE_GLOBAL);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getGlobalQueries(Module module)
        throws Exception
    {
        return QueryPeer.getQueries(module,
                null, (ScarabUser)data.getUser(),
                "name", "asc", QueryPeer.TYPE_GLOBAL);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getUserAllQueries()
        throws Exception
    {
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               "name", "asc", QueryPeer.TYPE_ALL_USER);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Query getDefaultQuery() throws Exception
    {
        Module currentModule   = getCurrentModule();
        ScarabUser currentUser = getCurrentUser();
        Integer currentUserId  = (currentUser==null)? null:currentUser.getUserId();
        return getDefaultQuery(currentModule, currentUserId);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Query getDefaultQuery(Module module) throws Exception
    {
        Integer ownerId = (module != null) ? module.getOwnerId():null;
        return getDefaultQuery(module, ownerId);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Query getDefaultQuery(Module module, Integer userId) throws Exception
    {
        return QueryPeer.getDefaultQuery(module, userId);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ReportBridge getReport()
        throws Exception
    {
        if (reportGenerator == null)
       {
            String key = data.getParameters()
                .getString(ScarabConstants.CURRENT_REPORT);
            ParameterParser parameters = data.getParameters();
            String id = parameters.getString("report_id");
            if (id == null || id.length() == 0)
            {
                ScarabUser user = (ScarabUser)data.getUser();
                MITList mitlist = user.getCurrentMITList();
                if (key == null)
                {
                    reportGenerator = getNewReport(mitlist);
                }
                else
                {
                    reportGenerator = user.getCurrentReport(key);

                    // if reportingIssue is still null, the parameter must have
                    // been stale, just get a new report
                    if (reportGenerator == null &&
                        mitlist != null && !mitlist.isEmpty())
                    {
                        reportGenerator = getNewReport(mitlist);
                    }
                }
            }
            else
            {
                reportGenerator = new ReportBridge(
                    ReportManager.getInstance(new NumberKey(id), false));
                key = ((ScarabUser)data.getUser())
                    .setCurrentReport(reportGenerator);
                data.getParameters()
                    .remove(ScarabConstants.CURRENT_REPORT);
                data.getParameters()
                    .add(ScarabConstants.CURRENT_REPORT, key);
            }
        }

        return reportGenerator;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private ReportBridge getNewReport(MITList mitList)
        throws Exception
    {
        if (mitList == null)
        {
            throw new IllegalArgumentException(
                "Cannot create a new report without any issue types."); //EXCEPTION
        }

        ScarabUser user = (ScarabUser)data.getUser();
        org.tigris.scarab.om.Report om  = new org.tigris.scarab.om.Report();
        ReportBridge report = new ReportBridge(om);
        report.setGeneratedBy(user);
        report.setMITList(mitList);

        String key = ((ScarabUser)data.getUser()).setCurrentReport(report);
        data.getParameters().add(ScarabConstants.CURRENT_REPORT, key);

        return report;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ScarabPaginatedList getUserSearchResults(MITList mitList,
                                                    int pageNum,
                                                    int resultsPerPage,
                                                    String sortColumn,
                                                    String sortPolarity,
                                                    boolean includeCommitters,
                                                    boolean confirmedOnly)
        throws Exception
    {
        return userFilteredSearchResults(mitList, pageNum, resultsPerPage,
                                         sortColumn, sortPolarity, "", "",
                                         includeCommitters, confirmedOnly);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ScarabPaginatedList getUserFilteredSearchResults(MITList mitList,
        int pageNum, int resultsPerPage,  String sortColumn,
        String sortPolarity, boolean includeCommitters, boolean confirmedOnly)
        throws Exception
    {
        String searchString = data.getParameters()
               .getString("searchString");
        String searchField = data.getParameters()
               .getString("searchField");

        if (searchField == null)
        {
            setInfoMessage(L10NKeySet.SearchFieldPrompt);
            return null ;
        }

        return userFilteredSearchResults(mitList, pageNum, resultsPerPage,
                                         sortColumn, sortPolarity,
                                         searchString, searchField, includeCommitters, confirmedOnly);

    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private ScarabPaginatedList userFilteredSearchResults(MITList mitList,
                                                          int pageNum,
                                                          int resultsPerPage,
                                                          String sortColumn,
                                                          String sortPolarity,
                                                          String searchString,
                                                          String searchField,
                                                          boolean includeCommitters, boolean confirmedOnly)
        throws Exception
    {
        ScarabPaginatedList list = null;
        String name = null;
        String userName = null;

        if ("FullName".equalsIgnoreCase(searchField))
        {
            name = searchString;
        }
        else if ("UserName".equalsIgnoreCase(searchField))
        {
            userName = searchString;
        }

        try
        {
            list = getCurrentModule().getUsers(name, userName, mitList,
                                               pageNum, resultsPerPage,
                                               sortColumn, sortPolarity,
                                               includeCommitters, confirmedOnly);
        }
        catch (Exception e)
        {
            Log.get().error("Problem getting user list", e);
            list = new ScarabPaginatedList();
        }

        // These are object members are used by GlobalMacros.vm via
        // the bean interface.  Leave them here until all users of the
        // paginate macro can be updated.
        this.nbrPages = list.getNumberOfPages();
        this.nextPage = list.getNextPageNumber();
        this.prevPage = list.getPrevPageNumber();

        return list;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getAttributeSearchResults()  throws Exception
    {
        String searchString = data.getParameters()
               .getString("searchString");
        String searchField = data.getParameters()
               .getString("searchField");
        if (searchField == null)
        {
            setInfoMessage(L10NKeySet.SearchFieldPrompt);
            return null ;
        }

        String name = null;
        String description = null;
        if (searchField.equals("Name") || searchField.equals("Any"))
        {
            name = searchString;
        }
        if (searchField.equals("Description") || searchField.equals("Any"))
        {
            description = searchString;
        }

        return sortAttributes(AttributePeer
            .getFilteredAttributes(name, description, searchField));
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List sortUsers(List userList)  throws Exception
    {
        return ScarabUserTool.sortUsers(userList, data);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List sortAttributes(List attList)  throws Exception
    {
        final String sortColumn = data.getParameters().getString("sortColumn");
        final String sortPolarity = data.getParameters().getString("sortPolarity");
        final int polarity = ("desc".equals(sortPolarity)) ? -1 : 1;
        Comparator c = new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                int i = 0;
                if (sortColumn != null && sortColumn.equals("name"))
                {
                    i =  polarity * ((Attribute)o1).getName()
                         .compareTo(((Attribute)o2).getName());
                }
                else
                {
                    i =  polarity * ((Attribute)o1).getDescription()
                         .compareTo(((Attribute)o2).getDescription());
                }
                return i;
             }
        };
        Collections.sort(attList, c);
        return attList;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public void resetAssociatedUsers() throws Exception
    {
        HashMap assoUsers = new HashMap();
        List issueList = getIssues();
        if (issueList != null)
        {
            for (int i=0; i<issueList.size(); i++)
            {
                Issue issue = (Issue)issueList.get(i);
                assoUsers.put(issue.getIssueId(), issue.getAssociatedUsers());
            }
            ((ScarabUser)data.getUser()).setAssociatedUsersMap(assoUsers);
        }
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public void resetSelectedUsers() throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        user.setSelectedUsersMap(null);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ScarabPaginatedList getPaginatedGlobalUsersList(int pageNum, int resultsPerPage,
    		String searchField, String searchCriteria, String sortColumn, String sortPolarity)
    	throws Exception
    {
    	ScarabPaginatedList paginated;
    	Criteria crit = new Criteria();
    	Criteria critCount = new Criteria();
    	crit.setOffset((pageNum-1)*resultsPerPage);
    	crit.setLimit(resultsPerPage);
    	crit.add(ScarabUserImplPeer.USER_ID, (Object)(ScarabUserImplPeer.USER_ID+" IS NOT NULL"), Criteria.CUSTOM);
        crit.addNotIn(ScarabUserImplPeer.CONFIRM_VALUE,new Object[]{"DELETED"} );
        critCount.addNotIn(ScarabUserImplPeer.CONFIRM_VALUE,new Object[]{"DELETED"} );

        if (searchField != null)
        {
            if (searchField.equals("LOGIN_NAME"))
                searchField = ScarabUserImplPeer.LOGIN_NAME;
            else if (searchField.equals("LAST_NAME"))
                searchField = ScarabUserImplPeer.LAST_NAME;
            else if (searchField.equals("FIRST_NAME"))
                searchField = ScarabUserImplPeer.FIRST_NAME;
            else if (searchField.equals("EMAIL"))
                searchField = ScarabUserImplPeer.EMAIL;
            crit.add(searchField, (Object)("%" + searchCriteria + "%"), Criteria.LIKE);
            critCount.add(searchField, (Object)("%" + searchCriteria + "%"), Criteria.LIKE);

            String col = ScarabUserImplPeer.FIRST_NAME;
            if (sortColumn.equals("LOGIN_NAME"))
                col = ScarabUserImplPeer.LOGIN_NAME;
            else if (sortColumn.equals("LAST_NAME"))
                col = ScarabUserImplPeer.LAST_NAME;
            else if (sortColumn.equals("FIRST_NAME"))
                col = ScarabUserImplPeer.FIRST_NAME;
            else if (sortColumn.equals("EMAIL"))
                col = ScarabUserImplPeer.EMAIL;
            if (sortPolarity.equalsIgnoreCase("asc"))
            {
                crit.addAscendingOrderByColumn(col);
            }
            else
            {
                crit.addDescendingOrderByColumn(col);
            }
        }

    	critCount.add(ScarabUserImplPeer.USER_ID, (Object)(ScarabUserImplPeer.USER_ID+" IS NOT NULL"), Criteria.CUSTOM);
    	List result = ScarabUserImplPeer.doSelect(crit);
    	critCount.addSelectColumn("COUNT(*)");
    	int totalResultSize = ScarabUserImplPeer.getUsersCount(critCount);
        if (totalResultSize > 0 && resultsPerPage > 0)
        {

            paginated = new ScarabPaginatedList(result, totalResultSize,
                                                pageNum,
                                                resultsPerPage);
        }
        else
        {
            paginated = new ScarabPaginatedList();
        }

    return paginated;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public MITList getMITList(List issues)
    throws Exception
    {
        ScarabUser user = getCurrentUser();
        return MITListManager.getInstanceFromIssueList(issues, user);
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getUserAttributes(List issues, boolean activeOnly)
        throws Exception
    {
        List attributes = null;
        if (issues == null || issues.isEmpty())
        {
            attributes = Collections.EMPTY_LIST;
            Log.get().warn("ScarabRequestTool.getUserAttributes issue list was"
                     + (issues == null ? " null" : " empty")) ;
        }
        else
        {
            attributes = getMITList(issues).getCommonUserAttributes(activeOnly);
        }

        return attributes;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Object getLastEnteredIssueTypeOrTemplate()
        throws Exception
    {
        Object result = null;
        IssueType issueType = getCurrentIssueType();
        ScarabUser user = (ScarabUser)data.getUser();
        String templateId = data.getParameters().getString("templateId");
        if (templateId != null && templateId.trim().length() > 0)
        {
            Issue template = getIssueTemplate(templateId);
            issueType = template.getIssueType().getIssueTypeForTemplateType();
            user.setLastEnteredTemplate(template);
            result = template;
        }

        if (result == null && issueType != null)
        {
            result = issueType;
            user.setLastEnteredIssueType(issueType);
        }

        if (result == null)
        {
            result = user.lastEnteredIssueTypeOrTemplate();
            if (result != null)
            {
                if (result instanceof Issue)
                {
                    issueType = ((Issue)result).getIssueType()
                        .getIssueTypeForTemplateType();
                }
                else if (result instanceof IssueType)
                {
                    issueType = (IssueType)result;
                }
                else
                {
                    Log.get().warn("An object of unexpected class was saved as"
                        + " the last entered issue type or template: " +
                        result.getClass().getName());
                    result = null;
                }

            }
        }

        // finally if we have a value, check that it is active
        if (issueType != null)
        {
            RModuleIssueType rmit =
                getCurrentModule().getRModuleIssueType(issueType);
            if (rmit == null || !rmit.getActive())
            {
                result = null;
            }
        }

        return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getSortedAttributeOptionsForRMIT(RModuleIssueType rmit) throws Exception
    {
    	List attributes = rmit.getIssueType().getActiveAttributes(rmit.getModule());
    	List result = new ArrayList();
    	for (Iterator it = attributes.iterator(); it.hasNext(); )
    	{
    		Attribute attr = (Attribute)it.next();
    		if (attr.getAttributeType().getAttributeClass().getName().equals("select-one"))
    			result.addAll(attr.getAttributeOptions());
    	}
    	return result;
    }
              
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public RModuleIssueType getRModuleIssueType(Integer moduleId, Integer issueTypeId) throws Exception
    {
        return RModuleIssueTypePeer.retrieveByPK(moduleId, issueTypeId);
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public ScarabUser getUserByUsername(String username) throws Exception
    {
        return ScarabUserManager.getInstance(username);
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Permission getPermissionByName(String name) throws Exception
    {
        Permission permission = null;
        permission = TurbineSecurity.getPermission(name);
        
        return permission;
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Role getRoleByName(String name) throws Exception
    {
        Role role = null;
        role = TurbineSecurity.getRole(name);
        
        return role;
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Group[] getGroups() throws Exception
    {
        Group[] allModules = TurbineSecurity.getAllGroups().getGroupsArray();
        return allModules;
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getActiveScarabModules() throws Exception
    {
        Group[] allModules = TurbineSecurity.getAllGroups().getGroupsArray();
        List result = new LinkedList();
        for(int index=0; index < allModules.length; index++)
        {
            if(allModules[index] instanceof ScarabModule)
            {
                ScarabModule module = (ScarabModule)allModules[index];
                if(!module.getDeleted())
                {
                    result.add(module);
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getNonMemberGroups(ScarabUser user) throws Exception
    {
        AccessControlList acl = user.getACL();
        Group[] groups = TurbineSecurity.getAllGroups().getGroupsArray();
        List nonmemberGroups = new LinkedList();
        for (int i=0; i<groups.length; i++) 
        {
            Module module = (Module)groups[i];
            if (!module.isGlobalModule() && !module.getDeleted()) 
            {
                RoleSet roleSet = acl.getRoles(groups[i]);
                if (roleSet == null || roleSet.size() == 0) 
                {
                    boolean hasRole = false;
                    // need to check for already requested roles
                    Role[] roles = 
                        TurbineSecurity.getAllRoles().getRolesArray();
                    for (int j=0; j<roles.length; j++) 
                    {
                        if (hasRequestedRole(user, roles[j], groups[i])) 
                        {
                            hasRole = true;
                            break;
                        }
                    }
                    if (!hasRole) 
                    {
                        nonmemberGroups.add(groups[i]);   
                    }                    
                }   
            }
        }
        return nonmemberGroups;
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Permission[] getPermissions() throws Exception
    {
        return (TurbineSecurity.getAllPermissions().getPermissionsArray());
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getPermissionsAsStrings() throws Exception
    {
        Permission[] allPerms = this.getPermissions();
        List list = new ArrayList(allPerms.length);
        for (int i=0; i<allPerms.length;i++)
        {
            list.add(allPerms[i].getName());
        }
        return list;
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Role[] getRoles() throws Exception
    {
        return TurbineSecurity.getAllRoles().getRolesArray();
    }
              
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getNonRootRoles() throws Exception
    {
        List nonRootRoles = new LinkedList();
        Role[] roles = TurbineSecurity.getAllRoles().getRolesArray();
        for (int i=0; i<roles.length; i++) 
        {
            Role role = roles[i];
            if (!role.getName().equals("Root")) 
            {
                nonRootRoles.add(role);
            }
        }
        return nonRootRoles;
    }
              
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static List sortUsers(List userList,  RunData data)  throws Exception
    {
        final String sortColumn = data.getParameters().getString("sortColumn");
        final String sortPolarity = data.getParameters().getString("sortPolarity");
        final int polarity = ("desc".equals(sortPolarity)) ? -1 : 1;
        Comparator c = new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                int i = 0;
                if ("username".equals(sortColumn))
                {
                    i =  polarity * ((ScarabUser)o1).getUserName()
                         .compareTo(((ScarabUser)o2).getUserName());
                }
                else
                {
                    i =  polarity * ((ScarabUser)o1).getName()
                         .compareTo(((ScarabUser)o2).getName());
                }
                return i;
             }
        };
        Collections.sort(userList, c);
        return userList;
    }
              
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
private String getInternal(String key) 
        throws Exception
    {
        String value = null;
        
        // Try with all defined "Browser"-Locales ordered by relevance
        Iterator iter = locales.iterator();
        while (value == null && iter.hasNext())
        {
            Locale locale = (Locale) iter.next();
            value = resolveKey(key, locale);
        }
        return value;
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllAttributes()
        throws Exception
    {
        return AttributePeer.getAttributes();
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAttributes(String attributeType)
        throws Exception
    {
        return AttributePeer.getAttributes(attributeType, false);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllAttributes(String attributeType, boolean includeDeleted,
                                 String sortColumn, String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes(attributeType, includeDeleted, 
                                           sortColumn, sortPolarity);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllAttributes(String sortColumn, String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes(sortColumn, sortPolarity);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getUserAttributes()
        throws Exception
    {
        return AttributePeer.getAttributes("user");
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getUserAttributes(String sortColumn, String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes("user", false, sortColumn, sortPolarity);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getUserAttributes(boolean includeDeleted, String sortColumn, 
                                  String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes("user", includeDeleted, sortColumn, sortPolarity);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAttributes(String attributeType, boolean includeDeleted, 
                              String sortColumn, String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes(attributeType, includeDeleted,
                                           sortColumn, sortPolarity);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllIssueTypes()
        throws Exception
    {
        return IssueTypePeer.getAllIssueTypes(false, "name", "asc");
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllIssueTypes(boolean deleted)
        throws Exception
    {
        return IssueTypePeer.getAllIssueTypes(deleted, "name", "asc");
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllIssueTypes(boolean deleted, String sortColumn, 
                                 String sortPolarity)
        throws Exception
    {
        return IssueTypePeer.getAllIssueTypes(deleted, sortColumn, sortPolarity);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getSearchUsers(String searchField, String searchCriteria)
        throws Exception
    {
        return (getSearchUsers(searchField, searchCriteria, null, null));
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getSearchUsers(String searchField, String searchCriteria, 
                               String orderByField, String ascOrDesc)
        throws Exception
    {
        ArrayList userSearchList = new ArrayList();
        String lSearchField = "";
        String lOrderByField = "";
        
        Criteria criteria = new Criteria();
        
        // add the input from the user
        if (searchCriteria != null && searchCriteria.length() > 0)
        {
            if (searchField.equals("FIRST_NAME"))
            {
                lSearchField = ScarabUser.FIRST_NAME;
            }
            else if (searchField.equals("LAST_NAME"))
            {
                lSearchField = ScarabUser.LAST_NAME;
            }
            else if (searchField.equals("LOGIN_NAME"))
            {
                lSearchField = ScarabUser.USERNAME;
            }
            else
            {
                lSearchField = ScarabUser.EMAIL;
            }
            
            // FIXME: Probably shouldn't be using ScarabUserPeerImpl here
            // What should we do to get the right table name?
            lSearchField = ScarabUserImplPeer.getTableName() + '.' + lSearchField;
            
            criteria = criteria.add(lSearchField,
                                        (Object)('%' + searchCriteria.trim() + '%'),Criteria.LIKE);
        }
        
        // sort the results
        if (orderByField != null && orderByField.length() > 0)
        {
            if (orderByField.equals("FIRST_NAME"))
            {
                lOrderByField = ScarabUser.FIRST_NAME;
            }
            else if (orderByField.equals("LAST_NAME"))
            {
                lOrderByField = ScarabUser.LAST_NAME;
            }
            else if (orderByField.equals("LOGIN_NAME"))
            {
                lOrderByField = ScarabUser.USERNAME;
            }
            else
            {
                lOrderByField = ScarabUser.EMAIL;
            }
            
            // FIXME: Probably shouldn't be using ScarabUserPeerImpl here
            // What should we do to get the right table name?
            lOrderByField = ScarabUserImplPeer.getTableName() + '.' + lOrderByField;
            
            if (ascOrDesc != null && ascOrDesc.equalsIgnoreCase("DESC"))
            {
                criteria = criteria.addDescendingOrderByColumn(lOrderByField);
            } 
            else
            {
                criteria = criteria.addAscendingOrderByColumn(lOrderByField);
            }
        }
        
        User[] tempUsers = TurbineSecurity.getUsers(criteria);  
        for (int i=0; i < tempUsers.length; i++)
        {
            userSearchList.add(i, tempUsers[i]);
        }
        return (userSearchList);
    }
              
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public SkipFiltering textToHTML(String text,
                                    ScarabLink link,
                                    Module currentModule) throws Exception
    {
        String renderEngine = currentModule.getCommentRenderingEngine();
        String txt;
        if(renderEngine.equals("radeox"))
        {
            txt = engine.render(text, context);
        }
        else if(renderEngine.equals("html")){
        	 txt = text;
        }
        else
        {
            txt = "<pre>" + 
                  perlUtil.substitute(REGEX_URL,
                  perlUtil.substitute(REGEX_MAILTO,
                  ReferenceInsertionFilter.filter(text)))
                  + "</pre>";
        }
        
        return new SimpleSkipFiltering(ScarabUtil.linkifyText(txt, link, currentModule));
    }
              
// in java/org/tigris/scarab/om/MITList.java
private List getMatchingRMOs(List rmos) throws TorqueException, Exception
    {
        List matchingRMOs = new ArrayList();
        if (rmos != null)
        {
            for (Iterator i = rmos.iterator(); i.hasNext();)
            {
                RModuleOption rmo = (RModuleOption) i.next();
                AttributeOption option = rmo.getAttributeOption();
                if (rmo.getActive() && isCommon(option))
                {
                    matchingRMOs.add(rmo);
                }
            }
        }
        return matchingRMOs;
    }
              
// in java/org/tigris/scarab/om/Activity.java
public String getDescription(ScarabLocalizationTool l10n)
        throws Exception
    {
        return getDisplayName(l10n) + ": " + getNewValue(l10n) + " (" + getOldValue(l10n) + ")";
    }
              
// in java/org/tigris/scarab/om/Activity.java
public String getOldValue(ScarabLocalizationTool l10n) 
    throws Exception
	{
	    return getOldValue(null, l10n);
	}
              
// in java/org/tigris/scarab/om/Activity.java
public String getOldValue(Issue issue, ScarabLocalizationTool l10n) 
        throws Exception
    {
        String value              = null;
        ActivityType activityType = getType();
        String oldValue           = getOldValue();
        
        if(   ActivityType.DEPENDENCY_DELETED.equals(activityType)
           || ActivityType.DEPENDENCY_CHANGED.equals(activityType))
        {
        	 value = getDepend().getIssueRelatedByObserverId().getUniqueId()
             + " < " + l10n.get(DependTypeManager.getManager().getL10nKey(oldValue)) + " > "
              + " " + getDepend().getIssueRelatedByObservedId().getUniqueId();       
        } 
        else if( ActivityType.ATTACHMENT_REMOVED.equals(activityType))
        {
             value = getAttachment().getFileName();
        } 
        else if( ActivityType.URL_DELETED.equals(activityType))
        {
             value = getAttachment().getData();
        } 
        else if( ActivityType.COMMENT_CHANGED.equals(activityType))
        {
             value = oldValue!=null ? firstChars( oldValue, 50 ) : "";
        } 
        else 
        {
        	//assumption that an attribute was changed
        	if(getAttribute() != null && getAttribute().isDateAttribute())
        	{
         		value = DateAttribute.dateFormat(oldValue!=null ? oldValue : "",  L10NKeySet.ShortDateDisplay.getMessage(l10n));
         	}
         	else
         	{
         		value = oldValue!=null ? oldValue : "";
         	}
        }

        return value;
    }
              
// in java/org/tigris/scarab/om/Activity.java
public String getNewValue(ScarabLocalizationTool l10n) throws Exception{
        return getNewValue(null, l10n);
    }
              
// in java/org/tigris/scarab/om/Activity.java
public String getNewValue(Issue issue, ScarabLocalizationTool l10n)
        throws Exception
    {
        String value = null;
        ActivityType activityType = getType();
        String newValue = getNewValue();
        
        if(   ActivityType.DEPENDENCY_CREATED.equals(activityType)
           || ActivityType.DEPENDENCY_CHANGED.equals(activityType))
        {
            if(newValue == null)
            {
                throw new RuntimeException("Dependency creation/change needs a new value. (Does imply that Dependency deletion is NOT supported?). The Error occured in issue " 
                          + issue.getParents()+ issue.getIdCount() );
            }
        	if(issue != null 
        			&& issue.getIssueId().intValue() != getDepend().getIssueRelatedByObservedId().getIssueId().intValue()
        			&& "blocking".equals(newValue))
        	{
            	value = getDepend().getIssueRelatedByObserverId().getUniqueId()
                + " " + l10n.get("DependsOn") //deprecated, but method is used many times in scarab.
            	+ " " + getDepend().getIssueRelatedByObservedId().getUniqueId(); 
            }
            else
            {
            	value = getDepend().getIssueRelatedByObservedId().getUniqueId()
            	+ " " + ("blocking".equals(newValue) ? l10n.get("PrerequisiteFor") : l10n.get(DependTypeManager.getManager().getL10nKey(newValue)))
                + " " + getDepend().getIssueRelatedByObserverId().getUniqueId();  
            }
        } 
        else if( ActivityType.ATTACHMENT_CREATED.equals(activityType))
        {
            value = getAttachment().getFileName();
        }
        else if(    ActivityType.URL_ADDED.equals(activityType)
                || ActivityType.COMMENT_ADDED.equals(activityType))
        {
            value = getAttachment().getData();
        }
        else if( ActivityType.COMMENT_CHANGED.equals(activityType))
        {
            value = newValue!=null ? firstChars( newValue, 50 ) : "";
        }
        else if( getType().equals(ActivityType.OTHER))
        {
            value = super.getDescription()!=null ? super.getDescription() : "";
        } 
        else 
        {
        	//assumption that an attribute was changed
        	if(getAttribute() != null && getAttribute().isDateAttribute())
        	{
        		value = DateAttribute.dateFormat(newValue!=null ? newValue : "",  L10NKeySet.ShortDateDisplay.getMessage(l10n));
        	}
        	else
        	{
        		value = newValue!=null ? newValue : "";
        	}            
        }
        return value;
    }
              
// in java/org/tigris/scarab/om/Activity.java
public String getDisplayName(ScarabLocalizationTool l10n)
        throws Exception
    {
        String name=null;
        if(this.getAttribute().getAttributeId().intValue()!=0)
        {
            name = getDisplayName();
        } else if(   getType().equals(ActivityType.OTHER))
        {
            name = l10n.get(L10NKeySet.OtherActivity);
        } else if(    getType().equals(ActivityType.ATTACHMENT_CREATED)
                   || getType().equals(ActivityType.ATTACHMENT_REMOVED))
        {
            name = l10n.get(L10NKeySet.Attachment);
        } else if(    getType().equals(ActivityType.DEPENDENCY_CREATED)
                   || getType().equals(ActivityType.DEPENDENCY_CHANGED)
                   || getType().equals(ActivityType.DEPENDENCY_DELETED))
        {
            name = l10n.get(L10NKeySet.Link);
        } else if(    getType().equals(ActivityType.URL_ADDED)
                   || getType().equals(ActivityType.URL_CHANGED)
                   || getType().equals(ActivityType.URL_DESC_CHANGED)
                   || getType().equals(ActivityType.URL_DELETED))
        {
            name = l10n.get(L10NKeySet.URL);
        } else if(    getType().equals(ActivityType.COMMENT_ADDED)
                   || getType().equals(ActivityType.COMMENT_CHANGED))
        {
            name = l10n.get(L10NKeySet.Comment);
        }
        else if(    getType().equals(ActivityType.ISSUE_COPIED)
                || getType().equals(ActivityType.ISSUE_MOVED)
                || getType().equals(ActivityType.ISSUE_CREATED)
                || getType().equals(ActivityType.ISSUE_DELETED))
	     {
	         name = l10n.get(L10NKeySet.IssueId);
	     }
        return name;
    }
              
// in java/org/tigris/scarab/om/Activity.java
public String getDisplayName()
        throws Exception
    {
        RModuleAttribute attr = getIssue().getModule().getRModuleAttribute(this.getAttribute(), this.getIssue().getIssueType());
        if (attr!=null)
            return attr.getDisplayValue();
        else
            return getAttribute().getName();
    }
              
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser reactivateUserIfDeleted(ScarabUser su) throws Exception
    {
        String username = su.getUserName();
        ScarabUser reactivatedUser=(ScarabUser) TurbineSecurity.getUser(username);
        String cs = reactivatedUser.getConfirmed();
        if(cs.equals(ScarabUser.DELETED))
        {
            reactivatedUser.setConfirmed(su.getConfirmed());
            reactivatedUser.setEmail(su.getEmail());
            String encryptedPassword = TurbineSecurity.encryptPassword(su.getPassword());
            reactivatedUser.setPassword(encryptedPassword);
            reactivatedUser.setFirstName(su.getFirstName());
            reactivatedUser.setLastName(su.getLastName());
            reactivatedUser.save();
            su = reactivatedUser;
            getMethodResult().remove(SCARAB_USER_MANAGER, GET_INSTANCE, username );
        } 
        else
        {
            su = null;
        }
        return su;
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public List getAncestors()
        throws TorqueException, Exception
    {
        ancestors = new ArrayList();
        AttributeOption parent = getParentOption();
        if (!ROOT_ID.equals(parent.getOptionId()))
        {
            addAncestors(parent);
        }
        return ancestors;
    }
              
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
private void addAncestors(AttributeOption option)
        throws TorqueException, Exception
    {
        if (!ROOT_ID.equals(option.getParent().getOptionId()))
        {
            if (ancestors.contains(option.getParent()))
            {
                throw new TorqueException("Tried to add a recursive parent-child " +
                                    "attribute option relationship."); //EXCEPTION
            }
            else
            { 
                addAncestors(option.getParent());
            }
        }
        ancestors.add(option.getOptionId());
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public ReportBridge getDefaultReport()
        throws Exception
    {     
        ReportBridge defaultReport=(ReportBridge) ModuleManager.getMethodResult()
           .get(this,GET_DEFAULTREPORT);
            
        if(defaultReport==null){
            String reportId = GlobalParameterManager.getString(GlobalParameter.DEFAULT_REPORT,this);
            Report report=reportId.equals("") ? null : 
                ReportManager.getInstance(new NumberKey(reportId));

            if(report!=null && !report.getDeleted())
            {
                defaultReport = new ReportBridge(report);     
                ModuleManager.getMethodResult().put(defaultReport,this,GET_DEFAULTREPORT);
            }
        }
            
        return defaultReport;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void addVote(ScarabUser user)
        throws ScarabException, Exception
    {
        // check to see if the user has voted for this issue
        int previousVotes = 0;
        IssueVote issueVote = null;
        Criteria crit = new Criteria()
            .add(IssueVotePeer.ISSUE_ID, getIssueId())
            .add(IssueVotePeer.USER_ID, user.getUserId());
        List votes = IssueVotePeer.doSelect(crit);
        if (votes != null && votes.size() != 0) 
        {
            issueVote = (IssueVote)votes.get(0);
            previousVotes = issueVote.getVotes();
        }
        else 
        {
            issueVote = new IssueVote();
            issueVote.setIssueId(getIssueId());
            issueVote.setUserId(user.getUserId());
        }

        // check if the module accepts multiple votes
        if (!getModule().allowsMultipleVoting() && previousVotes > 0)
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleVoteForUnallowed,
                                      user.getUserName(), 
                                      getUniqueId());
        }
        
        // save the user's vote
        issueVote.setVotes(previousVotes+1);
        issueVote.save();

        // update the total votes for the issue
        crit = new Criteria()
            .add(AttributeValuePeer.ATTRIBUTE_ID, 
                 AttributePeer.TOTAL_VOTES__PK);
        List voteValues = getAttributeValues(crit);
        TotalVotesAttribute voteValue = null;
        if (voteValues.size() == 0) 
        {
            voteValue = new TotalVotesAttribute();
            voteValue.setIssue(this);
            voteValue.setAttributeId(AttributePeer.TOTAL_VOTES__PK);
        }
        else 
        {
            voteValue = (TotalVotesAttribute)voteValues.get(0);
        }
        // Updating attribute values requires a activitySet
        ActivitySet activitySet = attachActivitySet(null, user, null, 
           ActivitySetTypePeer.RETOTAL_ISSUE_VOTE__PK);
        voteValue.startActivitySet(activitySet);
        voteValue.addVote();
        voteValue.save();
    }
              
// in java/org/tigris/scarab/om/Issue.java
public void deleteIssue(ScarabUser user)
        throws Exception, ScarabException
    {        
        if (user.hasPermission(ScarabSecurity.ISSUE__DELETE, this.getModule()))
        {
            ActivitySet activitySet = attachActivitySet(null, user);
            ActivityManager.createDeleteIssueActivity(this, activitySet);
            
            Attachment attachment = new Attachment();
            
            String note = Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "DeletedIssueNote");
            
            attachment.setData(note);
            attachment.setName(note);
            attachment.setTextFields(user, this, Attachment.MODIFICATION__PK);
            attachment.save();         
            
            this.setDeleted(true);
            List dependencies = this.getDependsRelatedByObservedId();
            dependencies.addAll(this.getDependsRelatedByObserverId());
            for (Iterator it = dependencies.iterator(); it.hasNext(); )
            {
                Depend depend = (Depend)it.next();
                if(!depend.getDeleted()){
                	ActivitySet deleteSet = 
                        this.doDeleteDependency(activitySet, depend, user);
                    for (Iterator act = deleteSet.getActivityList().iterator(); act.hasNext(); )
                    {
                        activitySet.addActivity((Activity)act.next());
                    }
                }        
            }
            
            activitySet.setAttachment(attachment);
            
            NotificationManagerFactory.getInstance()
            .addActivityNotification(ActivityType.ISSUE_DELETED,
                    activitySet, this, user);
            
            save();
        }
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
private List getActivityList(Issue issue, List activityTypes)
        throws Exception
    {
        List filteredActivities = new ArrayList();
        for(Iterator activities = getActivityList( issue ).iterator(); activities.hasNext();)
        {
            Activity activity = (Activity)activities.next();
            if(activityTypes.contains(ActivityType.getActivityType(activity.getActivityType())))
                filteredActivities.add(activity);
        }
        return filteredActivities;
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
private List getActivityList(Issue issue, ActivityType activityType)
        throws Exception
    {
        ActivityType[] types = {activityType};
        return getActivityList(issue, Arrays.asList(types));  
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public String getCommentForHistory(Issue issue) 
        throws Exception
    {
        String comment = null;
        List comments = getActivityList(issue, ActivityType.COMMENT_ADDED);
        if(comments.size()==1)
            comment=((Activity)comments.get(0)).getAttachment().getData();
        else
            comment=getActivityReason();
        
        return comment;
    }
              
// in java/org/tigris/scarab/om/ActivitySet.java
public List getActivityListForHistory(Issue issue) 
        throws Exception
    {
        return getActivityList(issue, historyTypeList);  
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public static void confirmUser (String username)
        throws Exception
    {
        User user = ScarabUserManager.getInstance(username);
        user.setConfirmed(User.CONFIRM_DATA);
        TurbineSecurity.saveUser(user);
        ScarabUserManager.getMethodResult().remove( ScarabUserManager.SCARAB_USER_MANAGER, ScarabUserManager.GET_INSTANCE, username );            
    }
              
// in java/org/tigris/scarab/om/ScarabModulePeer.java
public static boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        Criteria criteria = new Criteria();
        criteria.addSelectColumn(MODULE_ID);
        String name = ((Module)group).getRealName();
        criteria.add(MODULE_NAME, name);
        criteria.add(PARENT_ID, ((Module)group).getParentId());
        List results = BasePeer.doSelect(criteria);
        if(results.size() > 1)
        {
            throw new DataBackendException("Multiple groups named '" +
                name + "' exist!"); //EXCEPTION
        }
        return (results.size()==1);
    }
              
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private void sendEmail(EmailContext context, Issue issue, ScarabUser user)
            throws Exception
    {
        context.setSubjectTemplate("notification/IssueActivitySubject.vm");
        context.setDefaultTextKey(issue.getDefaultText());
        Set toUsers = new HashSet();
        toUsers.add(user);
        
        String[] fromUser    = getFromUser(issue, context);
        String[] replyToUser = issue.getModule().getSystemEmail();
        
        Email.sendEmail(
                context,
                issue.getModule(),
                fromUser,
                replyToUser,
                toUsers,
                null,
                "notification/IssueActivity.vm");
    }
              
// in java/org/tigris/scarab/xmlrpc/SimpleHandlerClient.java
public void testXmlRpc() throws Exception
    {
        XmlRpcClientComponent cli = new DefaultXmlRpcClientComponent();
        Vector v = new Vector();
        v.add("Pacman JVM");            // Module
        v.add("PAC1");                  // IssueID
        v.add("Administrator");         // User
        v.add("Prueba pruebilla");      // Comment
        v.add(new Integer(1));          // DISABLE email sending
        Vector vRdo = (Vector)cli.executeRpc(new URL("http://localhost:12345/simple"), "simple.addComment", v);
        System.out.println("The call was successful: " + (vRdo.size()==1));
        System.out.println("The comment was added: " + vRdo.get(0));
    }
              
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
protected boolean addComment(final Issue issue, final ScarabUser user,
            final String comment, final boolean disableEmails) throws Exception
    {

        log("adding comment to " + issue.getIssueId());
        
        // buffer the comment so we can break it down if MAX_COMMENT_SIZE != 0
        final BufferedReader reader = new BufferedReader(new StringReader(
                comment));
        // The comment Attachments that will be added to the issue.
        // This will only contain one Attachment when MAX_COMMENT_SIZE == 0
        final List comments = new LinkedList();
        final StringBuffer nextComment = new StringBuffer();
        String nextLine = "";
        do
        {
            nextLine = reader.readLine();

            if (nextLine == null || 
                  ( MAX_COMMENT_SIZE > 0 
                      && nextComment.length() + nextLine.length() > MAX_COMMENT_SIZE ) )
            {
                final Attachment attachment = new Attachment();
                attachment.setData(nextComment.toString());
                comments.add(0, attachment); // reverse order the list, it looks better on issue page.
                nextComment.setLength(0);
            }
            if (nextLine != null)
            {
                nextComment.append(nextLine + '\n');
            }

        } while (nextLine != null);

        // actually add the comment Attachments to issue
        synchronized (GlobalParameter.EMAIL_ENABLED)
        {
            // turn off emailing? we need to remember original state anyway...
            final boolean originalEmailState = GlobalParameterManager
                .getBoolean(GlobalParameter.EMAIL_ENABLED); 
            
            if (disableEmails && originalEmailState)
            {
                GlobalParameterManager.setBoolean(GlobalParameter.EMAIL_ENABLED, false);
            }
            for( Iterator it = comments.iterator(); it.hasNext(); )
            {
		Attachment attachment = (Attachment)it.next();
		if( attachment.getData() != null && attachment.getData().length() >0 )
		{
                	issue.addComment(attachment, user);
 	 	}
	    }
            if (disableEmails && originalEmailState)
            {
                GlobalParameterManager.setBoolean(GlobalParameter.EMAIL_ENABLED,
                          originalEmailState);
            }                
        }

        // [TODO] It isn't neccessary to do all of these, which one is the correct one?!?
        ScarabCache.clear();
        IssueManager.getMethodResult().clear();
        ModuleManager.getMethodResult().clear();

        return true;
    }
              
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
protected boolean changeIssueAttributeOption(final Issue issue,
            final ScarabUser user, final Attribute attribute,
            final AttributeOption option, final String description)
            throws Exception
    {

        final AttributeValue status = issue.getAttributeValue(attribute);
        final AttributeValue nyStatus = AttributeValue.getNewInstance(
                attribute, issue);
        nyStatus.setOptionId(option.getOptionId());
        //nyStatus.setActivityDescription(description);
        final Attachment attachment = new Attachment();
        attachment.setData(description);
        attachment.setName("comment");
        final HashMap newAttVals = new HashMap();
        newAttVals.put(status.getAttributeId(), nyStatus);
        final ActivitySet activitySet = issue.setAttributeValues(null,
                newAttVals, attachment, user);
        return true;
    }
              
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
protected Vector findIssuesWithAttributeValue(final ScarabUser user,
            final Attribute attribute, final String value) throws Exception
    {
        final Vector matchingIssueIds = new Vector();
        IssueSearch search = IssueSearchFactory.INSTANCE.getInstance(
               MITListManager.getAllModulesAllIssueTypesList(user), user);
        search.addAttributeValue(attribute, value);
        final List queryresults = search.getQueryResults();

        for(Iterator i=queryresults.iterator();i.hasNext();)
        {
            final QueryResult qr = (QueryResult) i.next();
            matchingIssueIds.add(qr.getUniqueId());
        }
        return matchingIssueIds;
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandlerClient.java
public void testXmlRpc() throws Exception
    {
        XmlRpcClientComponent cli = new DefaultXmlRpcClientComponent();
        Vector v = new Vector();
        Vector o = new Vector();
        v.add("Status");            // Module
        
        o.add("Newer");                  // IssueID
        o.add("Closed");                  // IssueID
        o.add("Killed");                  // IssueID
        o.add("Dunno");                  // IssueID
        v.add(o);
        
        Vector vRdo = (Vector)cli.executeRpc(new URL("http://localhost:12345/dmm"), "dmm.updateAttributeOptions", v);
        System.out.println("The call was successful: " + (vRdo.get(0)));
        System.out.println("The comment was added: " + vRdo.get(1));

        
        v = new Vector();
        v.add("Status");            // Module
        vRdo = (Vector)cli.executeRpc(new URL("http://localhost:12345/dmm"), "dmm.sortAttributeOptions", v);

        System.out.println("The call was successful: " + (vRdo.get(0)));
        System.out.println("The comment was added: " + vRdo.get(1));
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void addAttributeOption(String attribute, String optionName)
            throws Exception {
        // get the relevant entities
        AttributeOption option = getAttributeOption(attribute, optionName);
        Attribute attr = getOptionAttribute(attribute);
        setAttributeOptionDeletedFlag(attr, option, false);
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void removeAttributeOption(String attribute, String optionName)
            throws Exception {
        
        // get the relevant entities
        AttributeOption option = getAttributeOption(attribute, optionName);
        Attribute attr = getOptionAttribute(attribute);

        setAttributeOptionDeletedFlag(attr, option, true);
        option.deleteIssueTypeMappings();
        option.deleteModuleMappings();
       
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private AttributeOption getAttributeOption(String attribute, String option)
            throws Exception {
        // get all options related to this attribute
        Attribute attr = getOptionAttribute(attribute);        
        return AttributeOptionManager.getInstance(attr, option);
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void mapAttributeOptionToAllModuleIssueTypes(String attribute,
            String option) throws Exception {
        Iterator iter;
        AttributeOption ao = getAttributeOption(attribute, option);
        if (ao.getDeleted()) {
            ao.deleteIssueTypeMappings();
            ao.deleteModuleMappings();
        } else {
            // add module mappings
            iter = getModuleAttributes(attribute).iterator();
            while (iter.hasNext()) {
                RModuleAttribute rat = (RModuleAttribute) iter.next();
                IssueType it = rat.getIssueType();
                Module mod = rat.getModule();

                // skip template IssueTypes
                if (!isIssueTypeTemplate(it) &&
                   (mod.getRModuleOption(ao,it) == null)) {
                    if (log.isDebugEnabled()) {
                        log.debug("mapAttributeOptionToAllModuleIssueTypes(String, String) - Adding attribute to module/issuetype : ao=" + ao + ", rat=" + rat + ", it=" + it + ", mod=" + mod); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                    }
                    mod.addAttributeOption(it,ao);
                }                    
            }
            
            // add issuetype mappings
            iter = getIssueTypes(attribute).iterator();
            while (iter.hasNext()) {
                IssueType it = (IssueType) iter.next();
                try { 
                    it.addRIssueTypeOption(ao);
                } catch (TorqueException e) {
                    if (log.isEnabledFor(org.apache.log4j.Priority.WARN)) {
                        log
                                .warn(
                                        "mapAttributeOptionToAllModuleIssueTypes(String, String) - IssueTypeMApping alreadyt exists for this combination : attribute=" + attribute + ", option=" + option + ", it=" + it, null); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                    }
                }
            }

        }

    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void sortAttributeOptions(String attribute) throws Exception {
        Iterator iter;
        
        /**
         * Compare the order of  2 RModuleOptions based on their display value
         * 
         * @author pti
         *
         */
        final class RMOComparator implements Comparator {
            /**
             * Logger for this class
             */
            private final Logger log = Logger.getLogger(RMOComparator.class);

            public int compare(Object arg0, Object arg1) {
                // TODO Auto-generated method stub
                String s1 = ((RModuleOption)arg0).getDisplayValue();
                String s2 = ((RModuleOption)arg1).getDisplayValue();
                
                return s1.compareTo(s2);
            }
            
        };
        Comparator rmocomp = new RMOComparator();
        
        
        /**
         * Compare the order of  2 RIssueTypeOptions based on their display value
         * 
         * @author pti
         *
         */
        final class RIOComparator implements Comparator {
            /**
             * Logger for this class
             */
            private final Logger log = Logger.getLogger(RIOComparator.class);

            public int compare(Object arg0, Object arg1) {
                Integer oid1 = ((RIssueTypeOption)arg0).getOptionId();
                Integer oid2 = ((RIssueTypeOption)arg1).getOptionId();
                AttributeOption ao1=null;
                AttributeOption ao2=null;
                try {
                    ao1 = AttributeOptionPeer.retrieveByPK(oid1);
                    ao2 = AttributeOptionPeer.retrieveByPK(oid2);
                } catch (NoRowsException e) {
                    log.error("No Rows exception when sorting IssueTypeOptions.",e);
                } catch (TooManyRowsException e) {
                    log.error("Too many rows when sorting IssueTypeOptions.",e);
                } catch (TorqueException e) {
                    log.error("Torque exception when sorting IssueTypeOptions.",e);
                }
                
                return ao1.getName().compareTo(ao2.getName());
            }
            
        };
        Comparator riocomp = new RIOComparator();
        
        /**
         * Compare the order of  2 ParentChildAttributeOptions based on their display value
         * 
         * @author pti
         *
         */
        final class PCAOComparator implements Comparator {
            /**
             * Logger for this class
             */
            private final Logger log = Logger.getLogger(PCAOComparator.class);

            public int compare(Object arg0, Object arg1) {
                // TODO Auto-generated method stub
                String s1 = ((ParentChildAttributeOption)arg0).getName();
                String s2 = ((ParentChildAttributeOption)arg1).getName();
                
                return s1.compareTo(s2);
            }
            
        };
        Comparator pcaocomp = new PCAOComparator();
        
        
        Attribute attr = getAttribute(attribute);
        
        // sort module mappings
        iter = getModuleAttributes(attribute).iterator();
        while (iter.hasNext()) {
            RModuleAttribute rat = (RModuleAttribute) iter.next();
            IssueType it = rat.getIssueType();
            Module mod = rat.getModule();

            // skip template IssueTypes
            if (!isIssueTypeTemplate(it)) {
                List options = mod.getRModuleOptions(attr,it);
                Collections.sort(options, rmocomp);
                for (int i = 0; i < options.size(); i++) {
                    RModuleOption opt = (RModuleOption)options.get(i);
                    opt.setOrder(i + 1);
                    opt.save();
                }
                    
            }                    
        }
        
        // add issuetype mappings
        iter = getIssueTypes(attribute).iterator();
        while (iter.hasNext()) {
            IssueType it = (IssueType) iter.next();
            List options = it.getRIssueTypeOptions(attr);
            Collections.sort(options, riocomp);
            for (int i = 0; i < options.size(); i++) {
                RIssueTypeOption opt = (RIssueTypeOption)options.get(i);
                opt.setOrder(i + 1);
                opt.save();
            }
            
        }
        
        // sort pcao mappings
        List pcaos = attr.getParentChildAttributeOptions();
        Collections.sort(pcaos, pcaocomp);
        for (int i = 0; i < pcaos.size(); i++) {
            ParentChildAttributeOption opt = (ParentChildAttributeOption)pcaos.get(i);
            opt.setPreferredOrder(i + 1);
            opt.save();
        }

    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private void setAttributeOptionDeletedFlag(Attribute attr,
            AttributeOption option, boolean deleted) throws Exception {
        ParentChildAttributeOption pcao = ParentChildAttributeOption
                .getInstance();

        // claculate some sensible defaults
        int order = attr.getAttributeOptions().size() + 1;
        int weight = order;

        // populate the object and save it to db
        pcao.setAttributeId(attr.getAttributeId());
        pcao.setOptionId(option != null ? option.getOptionId() : null);
        pcao.setParentId(new Integer(0));
        pcao.setName(option.getName());
        pcao.setPreferredOrder(order);
        pcao.setWeight(weight);
        pcao.setDeleted(deleted);
        pcao.save();

    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void updateAttributeOptions(String attribute, List options)
            throws Exception {
        SyncStateMap ssm = new SyncStateMap();
        Iterator iter = null;

        // Retrieve attribute to be updated
        iter = getAttributeOptions(attribute).iterator();
        while (iter.hasNext()) {
            
            ssm.getSyncState(((AttributeOption)iter.next()).getName()).setInternal(true);
        }

        // create SyncState info based on given external list.
        iter = options.iterator();
        while (iter.hasNext()) {
            String option = (String) iter.next();
            ssm.getSyncState(option).setExternal(true);
        }

        // iterate over the syncstates
        iter = options.iterator();
        while (iter.hasNext()) {
            String key = (String) iter.next();
            SyncState ss = ssm.getSyncState(key);
            if (ss.isExternal() && !ss.isInternal()) {
                // new in external data : add to attribute options
                addAttributeOption(attribute, key);
                mapAttributeOptionToAllModuleIssueTypes(attribute, key);
            } else if (!ss.isExternal() && ss.isInternal()) {
                // no longer in external data : remove from option list
                removeAttributeOption(attribute, key);
                mapAttributeOptionToAllModuleIssueTypes(attribute, key);
            }
        }
    }
              
// in java/org/tigris/scarab/screens/ScarabDefault.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        context.put("modulelink", new ModuleSwitchingLink(data));
    }
              
// in java/org/tigris/scarab/screens/ViewAttachment.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        
        String attachId = data.getParameters().getString("attachId");
        Attachment attachment = AttachmentManager
            .getInstance(new NumberKey(attachId), false);
        String contentType = attachment.getMimeType();
        HttpServletResponse res = data.getResponse();
        res.setContentType(contentType);
        // disposition header does not seem to have that much value, but
        // adding it in a blind attempt to help win2K, IE client
        // to handle the downloads better
        if (!contentType.startsWith("text")) 
        {
            res.setHeader("Content-Disposition", 
                          "attachment; filename=" + attachment.getFileName());
        }
        
        File f = new File(attachment.getFullPath());
        
        if(!f.exists())
        {
            LocalizationKey key = L10NKeySet.AttachmentDoesNotExist;
            L10NMessage msg = new L10NMessage(key,attachment.getFullPath());
            getScarabRequestTool(context).setAlertMessage(msg);
            data.setTarget("Error.vm");
        }
        else
        {
            res.setContentLength((int)f.length());

            BufferedInputStream bis = null;
            OutputStream os = data.getResponse().getOutputStream();
            try
            {
                bis = new BufferedInputStream(new FileInputStream(f));
                byte[] bytes = new byte[2048];
                int s = 0;
                while ((s = bis.read(bytes)) != -1)
                {
                    try
                    {
                        os.write(bytes,0,s);
                    }
                    catch (java.io.IOException ioe)
                    {
                        Log.get().debug("File download was aborted: " + 
                                        attachment.getFullPath());
                        break;
                    }
                }
            }
            finally
            {
                if (bis != null)
                {
                    bis.close();
                }
            }
        }
        // we already sent the response, there is no target to render
        data.setTarget(null);
    }
              
// in java/org/tigris/scarab/screens/ReportExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        TSVPrinter printer = new TSVPrinter(getWriter(data));

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ReportBridge report = scarabR.getReport();

        // --------------------------------------------------------
        // This code is not generally excercised as the action will 
        // not redirect to this screen if the following conditions are 
        // present.  But is here to protect against url hacking.
        try 
        {
            String message = (String)scarabR.getInfoMessage();
            if (message != null && message.length() > 0)
            {
                printer.print(message);
            }
        }
        catch (Exception e)
        {
            printer.print(l10n.get("ErrorOccurredCheckingMessage"));
        }
        
        if (!report.isReadyForCalculation()) 
        {
            printer.print(l10n.get("IncompleteReportDefinition"));
            return;
        }

        if (report.getReportDefinition().reportQueryIsExpensive()) 
        {
            printer.print(l10n.format("ReportIsTooExpensive", String.valueOf(
                report.getReportDefinition().maximumHeadings())));
            return;
        }
        // --------------------------------------------------------

        ReportTableModel model = report.getModel(user);

        List rowHeadings = model.getRowHeadings();
        List columnHeadings = model.getColumnHeadings();
        int multiplier = 1;
        for (int level = 0; level < columnHeadings.size(); level++)
        {
            ReportHeading columnHeadingLevel =
                (ReportHeading) columnHeadings.get(level);
            int maxBlank = rowHeadings.size() - 1;
            if (maxBlank > 0)
            {
                for (int i = 1; i <= maxBlank; i++)
                {
                    // Empty heading cell.
                    printer.print(NO_HEADER);
                }
            }

            boolean singleAttribute = columnHeadingLevel.singleAttribute();
            // It would be preferable to concatenate an arrow
            // pointing to the right to the return value of
            // displayAttribute(), but I wasn't able to come up with a
            // good "down arrow" for the X-axis headings.
            printer.print(singleAttribute
                          ? model.displayAttribute(columnHeadingLevel.get(0))
                          : NO_HEADER);
            int colspan = model.getColspan(level);
            for (int i = 1; i <= multiplier; i++)
            {
                for (int nextIndex = 1; nextIndex <= columnHeadingLevel.size();
                     nextIndex++)
                {
                    Object heading = columnHeadingLevel.get(nextIndex - 1);
                    printer.print(reportLabel(model, heading, singleAttribute,
                                              l10n));
                }
                if (colspan > 1)
                {
                    for (int j = 2; j <= colspan; j++)
                    {
                        printer.print(NO_HEADER);
                    }
                }
            }

            // End of first heading row.
            printer.println();
            multiplier *= columnHeadingLevel.size();
        }

        for (Iterator i = rowHeadings.iterator(); i.hasNext(); )
        {
            i.next();
            printer.print(NO_HEADER);
        }
        int nbrColumns = model.getColumnCount();
        for (int i = 0; i < nbrColumns; i++)
        {
            printer.print(NO_HEADER);
        }
        printer.println();

        int nbrRows = model.getRowCount();

        if (rowHeadings.size() > 1
            || ((ReportHeading) rowHeadings.get(0)).singleAttribute())
        {
            for (int level = 0; level < rowHeadings.size(); level++)
            {
                ReportHeading curHeading =
                    (ReportHeading) rowHeadings.get(level);
                boolean singleAttribute = curHeading.singleAttribute();
                // "Down arrow" is prepend to displayAttribute() in
                // web view.
                printer.print(singleAttribute
                              ? model.displayAttribute(curHeading.get(0))
                              : NO_HEADER);
                    
            }
            for (int i = 0; i < nbrRows; i++)
            {
                printer.print(NO_HEADER);
            }
            printer.println();
        }

        DateFormat dateFormat = new SimpleDateFormat(Format.DATE_TIME_FMT);
        for (int rowIndex = 0; rowIndex < nbrRows; rowIndex++)
        {
            for (int level = 0; level < rowHeadings.size(); level++)
            {
                ReportHeading curHeading =
                    (ReportHeading) rowHeadings.get(level);
                boolean singleAttribute = curHeading.singleAttribute();
                int rowspan = model.getRowspan(level);
                if ((rowIndex % rowspan) == 0)
                {
                    int index = (rowIndex / rowspan) % curHeading.size();
                    printer.print(reportLabel(model, curHeading.get(index),
                                              singleAttribute, l10n));
                }
                else
                {
                    printer.print(NO_HEADER);
                }
            }

            for (int columnIndex = 0; columnIndex < nbrColumns; columnIndex++)
            {
                Object cell = model.getValueAt(rowIndex, columnIndex);
                String cellData = (ReportTableModel.isDate(cell)
                                   ? dateFormat.format((Date) cell)
                                   : cell.toString());
                if (StringUtils.isEmpty(cellData))
                {
                    cellData = NO_CONTENT;
                }
                printer.print(cellData);
            }

            printer.println();
        }
    }
              
// in java/org/tigris/scarab/screens/SaveTemplate.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception
    {
        String title = null;
        try
        {
            if (scarabR.getIssueTemplate().getIssueId() == null)
            {
                title = l10n.get("SaveTemplate");
            }
            else 
            {
                String name = scarabR.getIssueTemplateInfo().getName();
                String editTemplate = l10n.get("EditTemplate");
                StringBuffer sb = new StringBuffer(name.length() + 
                                                   editTemplate.length() + 4);
                sb.append(editTemplate).append(" '").append(name).append('\'');
                title = sb.toString();
            }
        }
        catch (Exception e)
        {
            title = l10n.get("SaveTemplate");
            Log.get().debug("no current issue type, cannot retrieve SaveTemplate title", e);
        }
        return title;
    }
              
// in java/org/tigris/scarab/screens/IssueListExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        ctx = context;

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        MITList mitlist = user.getCurrentMITList();
        TSVPrinter printer = new TSVPrinter(getWriter(data));
        List rmuas = scarabR.getRModuleUserAttributes();
        writeHeading(printer, mitlist, l10n, rmuas);
        writeRows(printer, mitlist, l10n, scarabR, rmuas);
    }
              
// in java/org/tigris/scarab/screens/IssueListExport.java
private void writeHeading(TSVPrinter printer, MITList mitlist, 
                              ScarabLocalizationTool l10n, List rmuas)
        throws Exception
    {

        printer.print((new L10NMessage(L10NKeySet.IssueId).getMessage(l10n)));

        // ISSUE ATTRIBUTE VALUES as column headings.
        if (containsElements(rmuas)) 
        {
            int count=0;
            for (Iterator i = rmuas.iterator(); i.hasNext();) 
            {
                RModuleUserAttribute rmua = (RModuleUserAttribute)i.next();
                Attribute userAttribute = rmua.getAttribute();
                String attrName = rmua.getName(l10n);
                Module module = rmua.getModule();
                if (module != null && mitlist.isSingleModuleIssueType())
                {
                    RModuleAttribute attr = rmua.getModule().getRModuleAttribute(userAttribute, mitlist.getIssueType());
                    if (attr != null)
                        attrName = attr.getDisplayValue();
                }
                printer.print(attrName);
                attributeTypes.put(Integer.toString(count), userAttribute.getAttributeType().getName());
                count++;
            }
            
        }
    }
              
// in java/org/tigris/scarab/screens/IssueListExport.java
private void writeRows(TSVPrinter printer, MITList mitlist, 
            ScarabLocalizationTool l10n, ScarabRequestTool scarabR, List rmuas)
        throws Exception
    {
        for (Iterator i = scarabR.getCurrentSearchResults().iterator();i.hasNext();)
        {
            printer.println();
            QueryResult queryResult = (QueryResult)i.next();
            writeRow(printer, mitlist, queryResult);
        }
        // print a newline when we're done to complete the last line;
        // this also ensures that the output is flushed
        printer.println();
    }
              
// in java/org/tigris/scarab/screens/IssueListExport.java
private void writeRow(TSVPrinter printer, MITList mitlist, QueryResult queryResult)
        throws Exception
    {

        printer.print(queryResult.getUniqueId());

        List values = queryResult.getAttributeValuesAsCSV();
        if (containsElements(values)) 
        {
            int count=0;
            for (Iterator itr = values.iterator();itr.hasNext();)
            {
                String val = (String)itr.next();
                String type = (String)attributeTypes.get(Integer.toString(count));
                count++;
                if (type.equals("date"))
                    val = DateAttribute.dateFormat(val, (new L10NMessage(L10NKeySet.ShortDatePattern).getMessage(getLocalizationTool(ctx))));
                if (val.length() == 0)
                {
                    printer.print(NO_CONTENT);
                }
                else
                {
                    printer.print(val);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/screens/ViewIssue.java
protected void doBuildTemplate(RunData data, TemplateContext context) throws Exception
    {
        super.doBuildTemplate(data, context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = null;
        
        String id = data.getParameters().getString("id");
		try{
			issue = getReferredIssue(id == null ? null : id.trim(), (ScarabModule)scarabR.getCurrentModule());
		}
		catch(Exception e){
			//ignore, this case will be handled later: issue == null
		}
        boolean hasViewPermission = false;
        boolean hasDeletePermission = false;
        // Deleted issues will appear to not have existed before
        if (issue == null || issue.getDeleted())
        {
             L10NMessage msg = new L10NMessage(L10NKeySet.IssueIdNotValid, id);
             scarabR.setAlertMessage(msg);
        }
        else
        {
            hasViewPermission = scarabR.hasPermission(ScarabSecurity.ISSUE__VIEW, issue.getModule());
            hasDeletePermission=scarabR.hasPermission(ScarabSecurity.ISSUE__DELETE, issue.getModule());
            context.put("currentIssue", issue);
            context.put("hasViewPermission", hasViewPermission?Boolean.TRUE:Boolean.FALSE);
            context.put("hasDeletePermission", hasDeletePermission?Boolean.TRUE:Boolean.FALSE);
            context.put("additionalDisplayAttributes", getAdditionalDisplayAttributes());
            if (!hasViewPermission)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.NoPermissionToViewIssue, id);
                scarabR.setAlertMessage(msg);
            }
            else if (issue.getMoved())
            {
                ScarabLink link = (ScarabLink)context.get("link");
                Issue newIssue = scarabR.getIssueIncludingDeleted(issue.getIssueNewId());
                L10NMessage msg = new L10NMessage(L10NKeySet.IssueIsNowLocatedIn,
                        link.getIssueIdLink(newIssue), newIssue.getUniqueId());
                scarabR.setAlertMessage(msg);
            }
        }
    }
              
// in java/org/tigris/scarab/screens/ViewIssue.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception
    {
        String title = (new L10NMessage(L10NKeySet.ViewIssue).getMessage(l10n));
        String currentIssueId = data.getParameters().getString("id");
        Issue issue = null;
        if (currentIssueId != null)
        {
            issue = scarabR.getIssue(currentIssueId);
        }
        if (issue != null) 
        {
            String name = issue.getModule().getRModuleIssueType(issue.getIssueType()).getDisplayName();
            String id = (new L10NMessage(L10NKeySet.ID).getMessage(l10n));
            String unique = issue.getUniqueId();
            title = name + " " + id + ": " + unique;
        }            
        return title;
    }
              
// in java/org/tigris/scarab/screens/ViewIssue.java
private List getAdditionalDisplayAttributes()
        throws Exception
    {
        List displayAttributeNames = GlobalParameterManager.getStringList(
            ADDITIONAL_DISPLAY_ATTRIBUTES
        );

        List displayAttributes = new ArrayList();
        for(Iterator names=displayAttributeNames.iterator();names.hasNext();)
        {
            final String displayAttributeName = (String)names.next();
            
            for(Iterator attributes = AttributePeer.getAttributes().iterator();attributes.hasNext();)
            {
                Attribute attribute = (Attribute)attributes.next();
                if(displayAttributeName.equals(attribute.getName())){
                    displayAttributes.add(attribute);
                }
            }
        }
        return displayAttributes;
    }
              
// in java/org/tigris/scarab/screens/IssueList.java
protected void doBuildTemplate(RunData data, TemplateContext context)
    throws Exception
    {
        super.doBuildTemplate(data, context);
        populateContextWithQueryResults(data, context);
        
    }
              
// in java/org/tigris/scarab/screens/IssueList.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n)
        throws Exception
    {
        if (scarabR.getQuery() != null
            && StringUtils.isNotBlank(scarabR.getQuery().getName()))
        {
            return l10n.format("IssueList.vm.TitleWithQueryName",
                               scarabR.getQuery().getName());
        }
        else
        {
            return super.getTitle(scarabR,l10n);
        }
    }
              
// in java/org/tigris/scarab/screens/SelectModule.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        context.put("modulelink", new ModuleSwitchingLink(data));
    }
              
// in java/org/tigris/scarab/screens/home/XModuleList.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        ScarabUser user = (ScarabUser)data.getUser();
        MITList currentList = user.getCurrentMITList();
        if (currentList != null && !currentList.isModifiable()) 
        {
            user.setCurrentMITList(null);
        }
    }
              
// in java/org/tigris/scarab/screens/IssueTypeList.java
protected void doBuildTemplate(RunData data, TemplateContext context) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module module = scarabR.getCurrentModule();
        if (null == module || module.getIssueTypes() == null || module.getIssueTypes().size() == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.NoIssueTypesAssociatedToModule);
            context.put("issueTypesAvailaible", Boolean.FALSE);
        }
        else
        {
            context.put("issueTypesAvailaible", Boolean.TRUE);
        }
        super.doBuildTemplate(data, context);
    }
              
// in java/org/tigris/scarab/screens/Default.java
public String doBuild(RunData data) throws Exception
    {
        super.doBuild(data);
        return "";
    }
              
// in java/org/tigris/scarab/screens/Default.java
protected void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        // This may not be the best location for this, we might need to create
        // a valve.
        // check that the module exists, it may not have been created yet.
        try
        {
            scarabR.getCurrentModule();
        }
        catch (Exception ignore)
        {
        }

        // add the title text to the context.
        ScarabLocalizationTool l10n =
            (ScarabLocalizationTool) context.get("l10n");

        // Determine whether this target requires issue types.
        String altTarget = getTargetForNoIssueTypes(data);
        boolean changeTarget = false;
        if (altTarget != null)
        {
            List issueTypes = scarabR.getCurrentModule().getIssueTypes(true);
            changeTarget = (issueTypes == null || issueTypes.isEmpty());
        }

        if (changeTarget)
        {
            // Pass control to the alternate target.
            scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
            setTarget(data, altTarget);
        }
        else
        {
            // Add the title text to the context.
            String title = null;
            try
            {
                title = getTitle(scarabR, l10n);
            }
            catch (Exception e)
            {
                Log.get().info(
                    "Error getting page title for Screen: " + data.getTarget());
            }
            if (title == null)
            {
                title = "Scarab";
            }
            context.put("title", title);
        }
    }
              
// in java/org/tigris/scarab/screens/Default.java
protected String getTitle(ScarabRequestTool scarabR, ScarabLocalizationTool l10n)
        throws Exception
    {
        return l10n.getTitle();
    }
              
// in java/org/tigris/scarab/screens/Default.java
protected boolean isAuthorized(RunData data) throws Exception
    {
        return checkAuthorized(data);
    }
              
// in java/org/tigris/scarab/screens/Default.java
public static boolean checkAuthorized(RunData data) throws Exception
    {
        String template = data.getTarget();
        {
            template = template.replace(',', '.');
            String perm = ScarabSecurity.getScreenPermission(template);
            TemplateContext context = getTemplateContext(data);
            ScarabRequestTool scarabR = getScarabRequestTool(context);
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            Module currentModule = scarabR.getCurrentModule();
            ScarabUser user = (ScarabUser) data.getUser();
            if (perm != null)
            {
                if (!user.hasLoggedIn()
                    || !user.hasPermission(perm, currentModule))
                {
                    scarabR.setInfoMessage(L10NKeySet.LoginToAccountWithPermissions);
                    // it is very common to come from email to view a
                    // particular issue.  Until a more general formula for
                    // deciding which requests might be ok to continue after
                    // a login, we will at least allow this one.
                    if ("ViewIssue.vm".equals(data.getTarget()))
                    {
                        data.getParameters().setString(
                            "viewIssueId",
                            data.getParameters().getString("id"));
                    }

                    setTargetLogin(data);
                    scarabR.setCurrentModule(null);
                    return false;
                }
                else if (currentModule == null)
                {
                    Log.get().debug("Current module is null");
                    scarabR.setInfoMessage(L10NKeySet.SelectModuleToWorkIn);
                    setTargetSelectModule(data);
                    return false;
                }
            }
            // does the user at least have a role in the module?
            // we don't check user.hasLoggedIn() here because guest
            // users could have a role in a module.
            else if (
                currentModule != null && !user.hasAnyRoleIn(currentModule) 
                     && !user.hasAnyRoleIn(
                         ModuleManager.getInstance(Module.ROOT_ID)))
            {
                if (Log.get().isDebugEnabled())
                {
                    Log.get().debug(
                        "User ("
                            + user.getUserId()
                            + ") did not have any roles in current module"
                            + currentModule.getName());
                }
                scarabR.setCurrentModule(null);
                data.getParameters().remove(ScarabConstants.CURRENT_MODULE);
                scarabR.setAlertMessage(L10NKeySet.NoPermissionInModule);
                setTargetSelectModule(data);
                return false;
            }
            /* FIXME
               Breaks the ability to request roles because the permission is null and
               the module is null, but we are logged in. John, we should assign default
               permissions to each screen so that we can make it so that someone can be
               logged in, but not select a module yet and be shown the select module
               screen. (JSS)
            
                        else if (currentModule == null &&
                                 user != null &&
                                 user.hasLoggedIn())
                        {
                            setTargetSelectModule(data);
                            return true;
                        }
            */
        }
        return true;
    }
              
// in java/org/tigris/scarab/screens/admin/AttributeOptionSelect.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       String name = scarabR.getAttribute().getName();
       return l10n.format("AddGlobalAttributeOptionToAttribute", name);
    }
              
// in java/org/tigris/scarab/screens/admin/ViewXMLExportIssues.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
              
        super.doBuildTemplate(data, context);

        // probably should use intake, but i'm being lazy for now cause
        // this is only three form variables and not worth the trouble...
        // [hair] it is actually very useful that data.getParameters() is used
        // because it means that the xml results can be fetched through a Http GET
        // as well as the normal POST.
        String filename = data.getParameters().getString("filename");
        if (filename == null 
            || filename.length() == 0 
            || filename.indexOf('/') > 0
            || filename.indexOf(':') > 0
            || filename.indexOf(';') > 0)
        {
            filename = "scarab-issues-export.xml";
        }

        final ScarabRequestTool scarabR = getScarabRequestTool(context);
        final Module currentModule = scarabR.getCurrentModule();
        final ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        final ScarabUser user = (ScarabUser)data.getUser();
        
        // new functionality allows query parameter to select which issues to print
        final String query = data.getParameters().getString("go");
        String ids = null;
        final List allIdList = new ArrayList();
        if( query != null )
        {
            final StringBuffer sb = new StringBuffer();
            final Search searchAction = new Search();
            searchAction.doSelectquery(data, context);
            final Iterator it = scarabR.getCurrentSearchResults().iterator();
            while(it.hasNext())
            {
                final QueryResult issue = (QueryResult)it.next();
                // only add the result if the user would otherwise be able to view it.
                if( user.hasPermission(ScarabSecurity.ISSUE__VIEW, issue.getIssue().getModule()) ){
                    
                    sb.append(issue.getIssue().getIdPrefix()+issue.getIssue().getIdCount());
                    allIdList.add(issue.getIssue().getIdPrefix()+issue.getIssue().getIdCount());
                    if(it.hasNext())
                    {
                        sb.append(',');
                    }
                }
            }
            ids = sb.toString();
        }else{
            // issues are defined manually
            ids = data.getParameters().getString("exportissues");
        }
        context.put("exportissues", ids);
        if (ids == null || ids.length() == 0)
        {
            data.setTarget("admin,XMLExportIssues.vm");
            scarabR.setAlertMessage(l10n.get("EnterIssues"));
            return;
        }
        else
        {
            // manually specified ids we need parse & verify
            if( allIdList.isEmpty() )
            {
                try
                {
                    // FIXME! we need this method to return valid ids, if the range
                    // is thousands of issues, we cannot post verify the issues.
                   allIdList.addAll( Issue.parseIssueList(currentModule, ids) );
                }
                catch (Exception e)
                {
                    data.setTarget("admin,XMLExportIssues.vm");
                    scarabR.setAlertMessage(l10n.getMessage(e));
                    return;
                }
            }
            final List issueIdList = new ArrayList();
            final List badIdList = new ArrayList();
            final Integer currentModuleId = currentModule.getModuleId();
            final String defaultCode = currentModule.getCode();
            for (Iterator itr = allIdList.iterator(); itr.hasNext();)
            {
                final String tmp = (String) itr.next();
                final Issue issue = IssueManager.getIssueById(tmp, defaultCode);
                // check that the issue is in the current module, don't allow
                // exporting of issues other than those in the current
                // module for security reasons
                if (issue != null && !issue.getDeleted() )
                {
                    issueIdList.add(tmp);
                }
                else
                {
                    badIdList.add(tmp);
                }
            }
            if (issueIdList.isEmpty())
            {
                data.setTarget("admin,XMLExportIssues.vm");
                scarabR.setAlertMessage(l10n.get("NoValidIssuesCouldBeLocated"));
                return;
            }
            else if (!badIdList.isEmpty())
            {
                data.setTarget("admin,XMLExportIssues.vm");
                scarabR.setAlertMessage(
                    l10n.format("FollowingIssueIdsAreInvalid", 
                    badIdList.toString()));
                return;
            }

            String contentType;
            String contentDisposition;
            if ("1".equals(data.getParameters().getString("downloadtype")))
            {
                // To browser window.
                contentType = "text/xml";
                contentDisposition = "inline";
            }
            else
            {
                // Save to file.  Unforunately, not all browsers are
                // created equal, and some fail to fully heed the
                // Content-disposition header.  We hack around this by
                // using a Content-type header which indicates binary
                // data.
                //contentType = "text/xml";
                contentType = "application/octet-stream";
                contentDisposition = "attachment";
            }
            data.getResponse().setContentType(contentType);
            data.getParameters().add("content-type", contentType);
            contentDisposition += "; filename=" + filename;
            data.getParameters().add("content-dispostion", contentDisposition);
            data.getResponse().setHeader("Content-Disposition",
                                         contentDisposition);
    
            context.put("issueIdList", issueIdList);
            final VelocityContext vc = new VelocityContext();
            for (Iterator keys = context.keySet().iterator(); keys.hasNext(); )
            {
                final String key = (String) keys.next();
                vc.put(key, context.get(key));
            }
            vc.put("dtdURI", ImportIssues.SYSTEM_DTD_URI);

            final String encoding = Turbine.getConfiguration()
                .getString("scarab.dataexport.encoding");
            if (encoding != null && !encoding.equals(""))
            {
                TurbineVelocity.handleRequest
                    (vc, "macros/XMLExportIssuesMacro.vm",
                     data.getResponse().getOutputStream(), encoding, encoding);
            }
            else
            {
                TurbineVelocity.handleRequest
                    (vc, "macros/XMLExportIssuesMacro.vm",
                     data.getResponse().getOutputStream());
            }
    
            // we already sent the response, there is no target to render
            data.setTarget(null);
        }
    }
              
// in java/org/tigris/scarab/screens/admin/ViewXMLExportSettings.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);

        // probably should use intake, but i'm being lazy for now cause
        // this is only three form variables and not worth the trouble...
        String downloadType = data.getParameters().getString("downloadtype");
        if (downloadType != null && downloadType.equals("1"))
        {
            data.getResponse().setContentType("text/plain");
        }
        else
        {
            data.getResponse().setContentType("application/octet-stream");
            String filename = data.getParameters().getString("filename");
            if (filename == null 
                || filename.length() == 0 
                || filename.indexOf('/') > 0
                || filename.indexOf(':') > 0
                || filename.indexOf(';') > 0)
            {
                filename = "scarab-settings-export.xml";
            }
            data.getResponse().setHeader("Content-Disposition", 
                "attachment; filename=" + filename);
        }

        String includeUsers = data.getParameters().getString("includeUsers");
        if (includeUsers != null && includeUsers.equals("1"))
        {
            context.put ("includeUsers", Boolean.TRUE);
        }
        else
        {
            context.put ("includeUsers", Boolean.FALSE);
        }
        
        context.put("renderedFromScreen", Boolean.TRUE);
        context.put("sdf", new SimpleDateFormat(ScarabConstants.DATE_FORMAT));
        String result = 
            Module.handleRequest (context, "macros/XMLExportSettingsMacro.vm");
        data.getResponse().setContentLength(result.length());
        data.getResponse().getOutputStream().print(result);
        context.remove("renderedFromScreen");

        // we already sent the response, there is no target to render
        data.setTarget(null);
    }
              
// in java/org/tigris/scarab/screens/admin/ArtifactTypeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   { 
       String name = scarabR.getCurrentModule().getRModuleIssueType(scarabR.getIssueType()).getDisplayName();
       return l10n.format("EditIssueType", name);
    }
              
// in java/org/tigris/scarab/screens/admin/GlobalArtifactTypeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       IssueType issueType = scarabR.getIssueType();
       String title = null;
       if (issueType.getIssueTypeId() != null)
       {
           String name = issueType.getName();
           title = l10n.format("EditGlobalIssueType", name);
       }
       else 
       {
           title = l10n.get("CreateNewIssueType");            
       }
       return title;
    }
              
// in java/org/tigris/scarab/screens/admin/UserAttributeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       Attribute attribute = scarabR.getAttribute();
       String title = null;
       if (attribute.getAttributeId() != null)
       {
           String name = attribute.getName();
           title = l10n.format("EditGlobalUserAttribute", name);
       }
       else 
       {
           title = l10n.get("CreateNewGlobalUserAttribute");            
       }
       return title;
    }
              
// in java/org/tigris/scarab/screens/admin/ManageArtifactTypes.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
           return l10n.format("ManageIssueTypes", 
                              scarabR.getCurrentModule().getRealName());
    }
              
// in java/org/tigris/scarab/screens/admin/ActivityList.java
protected void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        ParameterParser pp = data.getParameters();
        String fromPk = pp.getString("frompk");
        String toPk = pp.getString("topk");
        String fromDateString = pp.getString("fromdate");
        String toDateString = pp.getString("todate");
        boolean isByPk = "pk".equals(pp.get("sort")) || (fromPk != null)
            || (toPk != null);
        // max=# will give the number of records, -1 will return all records
        //int max = pp.getInt("max", 100);

        Criteria crit = new Criteria();
        Criteria.Criterion c = null;
        if (isByPk) 
        {
            crit.addAscendingOrderByColumn(ActivitySetPeer.TRANSACTION_ID);
            if (fromPk != null) 
            {
                c = crit.getNewCriterion(ActivitySetPeer.TRANSACTION_ID, 
                                         fromPk, Criteria.GREATER_EQUAL);
            }
            if (toPk != null) 
            {
                if (c == null) 
                {
                    c = crit.getNewCriterion(ActivitySetPeer.TRANSACTION_ID, 
                                             toPk, Criteria.LESS_EQUAL);
                }
                else 
                {
                    c.and(crit.getNewCriterion(ActivitySetPeer.TRANSACTION_ID, 
                                               toPk, Criteria.LESS_EQUAL));
                    
                }
            }
        }
        else 
        {
            crit.addAscendingOrderByColumn(ActivitySetPeer.CREATED_DATE);

            if (fromDateString != null) 
            {
                c = crit.getNewCriterion(ActivitySetPeer.CREATED_DATE, 
                                         parseDate(fromDateString), 
                                         Criteria.GREATER_EQUAL);
            }

            if (toDateString != null) 
            {
                if (c == null) 
                {
                    c = crit.getNewCriterion(ActivitySetPeer.CREATED_DATE, 
                                             parseDate(toDateString), 
                                             Criteria.LESS_EQUAL);
                }
                else 
                {
                    c.and(crit.getNewCriterion(ActivitySetPeer.CREATED_DATE, 
                                               parseDate(toDateString), 
                                               Criteria.LESS_EQUAL));
                }
            }
        }
        if (c != null) 
        {
            crit.add(c);
        }
        
        final List sets = ActivitySetPeer.doSelect(crit);
        // the following iterator starts at the end of the list and
        // iterates toward the beginning, removing items from the list
        // as it goes.  This helps with memory usage.  The original list
        // size can still be too large, but if it is not, processing by
        // the template should not add additional memory burden.
        Iterator setIterator = new Iterator()
            {
                public boolean hasNext()
                {
                    return !sets.isEmpty();
                }

                public Object next()
                {
                    ScarabCache.clear();
                    return sets.remove(sets.size()-1);
                }

                public void remove()
                {
                    //not implemented
                }
            };
        context.put("activitySets", setIterator);
    }
              
// in java/org/tigris/scarab/screens/admin/GlobalAttributeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       Attribute attribute = scarabR.getAttribute();
       String title = null;
       if (attribute.getAttributeId() != null)
       {
           String name = attribute.getName();
           title = l10n.format("EditGlobalAttribute", name);
       }
       else 
       {
           title = l10n.get("CreateNewGlobalAttribute");            
       }
       return title;
    }
              
// in java/org/tigris/scarab/screens/admin/ModuleAttributeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       Attribute attribute = scarabR.getAttribute();
       Module module = scarabR.getCurrentModule();
       IssueType issueType = scarabR.getIssueType();
       
       String title;
       if (attribute == null) 
       {
           title = l10n.get("NoAttributeToEdit");
           Log.get().warn(
               "No attribute id was specified for ModuleAttributeEdit.");
       }
       else 
       {
           if (module == null || issueType == null)
           {
               // such a condition is probably going to give errors
               // elsewhere, but we can at least return a global name.
               title = attribute.getName();
               Log.get().warn("Current module or issue type id was not " +
                               "specified for ModuleAttributeEdit");
           }
           else 
           {
               RModuleAttribute rma = module
                   .getRModuleAttribute(attribute, issueType);
               if (rma == null) 
               {
                   // again, such a condition is probably going to give errors
                   // elsewhere, but we can at least return a global name.
                   title = attribute.getName();           
                   Log.get().warn(
                       "rma is null in ModuleAttributeEdit.");
               }
               else 
               {
                   title = rma.getDisplayValue();
               }
           }
       }

       return l10n.format("EditModuleAttribute", title);
    }
              
// in java/org/tigris/scarab/screens/admin/ModuleAttributeEdit.java
public void doBuildTemplate(RunData data, TemplateContext context)
    throws Exception
    {
    	super.doBuildTemplate(data, context);
    	
    	// workaround to avoid calling the same template once again as cancel template
    	// SCB2624
    	String cancelTemplate = getCancelTemplate(data);
    	if(cancelTemplate == null || cancelTemplate.equals("admin,ModuleAttributeEdit.vm")){
    		data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE, "admin,AttributeGroupEdit.vm");
    	}
    	
    }
              
// in java/org/tigris/scarab/screens/admin/AttributeGroupEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       String groupId = data.getParameters().getString("groupid");
       AttributeGroup group = scarabR.getAttributeGroup(groupId);
       String title = null;
       if (group == null) 
       {
           title = l10n.get("AddAttributeGroup");
       }
       else 
       {
           title = l10n.format("EditAttributeGroup", group.getName());
       }
       return title;
    }
              
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
public void doBuildTemplate(final RunData data, 
            final TemplateContext context)
        throws Exception
    {
        
        String resultString = "";
        int resultCode = RESULT_OK;
        Collection importErrors = null;
        ScarabIssues si = null;

        super.doBuildTemplate(data, context);
        final ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        if (isImportAuthorized(data))
        {
            final FileItem issuesToImport = data.getParameters()
                .getFileItem("issues");
            
            if (issuesToImport != null 
                && issuesToImport.getSize() >= MIN_XML_SIZE)
            {
                try
                {
                    final ScarabUser user = (ScarabUser)data.getUser();
                    final ImportIssues importIssues = new ImportIssues(
                            user.hasPermission(ScarabSecurity.DOMAIN__ADMIN, (Module)null),
                            user.hasPermission(ScarabSecurity.DOMAIN__ADMIN, (Module)null),
                            data.getServletConfig().getServletContext().getRealPath("/") + "/WEB-INF/attachments/");
                    final ScarabRequestTool scarabR = getScarabRequestTool(context);
                    final String type = data.getParameters().getString("xmlFormat");
                    
                    importErrors = importIssues.runImport(
                            issuesToImport, 
                            scarabR.getCurrentModule(),
                            ImportIssues.ImportType.valueOf(type));
                    
                    si = importIssues.getScarabIssuesBeanReader();
                    if (importErrors != null && !importErrors.isEmpty())
                    {
                        resultCode = RESULT_ERROR_INVALID_ISSUE_DATA;
                        resultString = l10n.get("ProcessingErrors");
                    }
                }
                catch (Exception e)
                {
                    resultCode = RESULT_ERROR_EXCEPTION;
                    // TODO: Improve localizability of this text.
                    resultString = l10n.get("ProcessingErrors") + ": "
                        + e.getMessage();
                }
            }
            else
            {
                resultCode = RESULT_ERROR_XML_MISSING;
                resultString = l10n.get("MissingXML");
            }
        }
        else
        {
            resultCode = RESULT_ERROR_UNAUTHORIZED;
            resultString = l10n.get("Unauthorized");
        }

        context.put("resultString", resultString);
        context.put("resultCode", new Integer(resultCode));
        context.put("importErrors", importErrors);
        context.put("issues", si);
        
        final String format = data.getParameters().getString("format");
        if (format != null && format.equals("xml")) 
        {
            final String result = org.apache.turbine.modules.Module.handleRequest
                (context, "macros/XMLImportIssuesResultsMacro.vm");
            data.getResponse().setContentType("text/plain");
            data.getResponse().setContentLength(result.length());
            data.getResponse().getOutputStream().print(result);
    
            // we already sent the response, there is no target to render
            data.setTarget(null);
        }
    }
              
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
protected boolean isAuthorized(RunData data) throws Exception
    {
        return (true);
    }
              
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
private boolean isImportAuthorized(RunData data) 
        throws Exception
    {
        String perm = ScarabSecurity.getScreenPermission
            ("admin.XMLImportIssuesResults.vm");
        TemplateContext context = getTemplateContext(data);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module currentModule = scarabR.getCurrentModule();
        ScarabUser user = (ScarabUser) data.getUser();
        boolean result = false;

        if (perm != null) // Is there is a permission for this?
        {
            if (user.hasLoggedIn() &&
                    user.hasPermission(perm, currentModule))
            {
                result = true; // Confirmed user has permission
            }
        }
        else
        {
            result = true; // No permission = unsecured
        }

        return (result);
    }
              
// in java/org/tigris/scarab/screens/admin/ConditionEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   { 
       String name = scarabR.getCurrentModule().getRModuleIssueType(scarabR.getIssueType()).getDisplayName();
       return l10n.format("ConditionEdit", name);
    }
              
// in java/org/tigris/scarab/screens/RSSDataExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
			throws Exception {
		super.doBuildTemplate(data, context);

		data.getResponse().setContentType(MIME_TYPE);

		// we will send the response, so no target to render
		data.setTarget(null);
		
		Writer writer = data.getResponse().getWriter();
		
		try {
            ParameterParser parser = data.getParameters();



            String feedType = parser.getString(FEED_TYPE_KEY);
            if(feedType == null)
            {
                String msg = COULD_NOT_FIND_FEED_TYPE;
                Log.get().error(msg);
                data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);            
                return;
            }

            String feedFormat = parser.getString(FEED_FORMAT_KEY);

            ScarabLink scarabLink= getScarabLinkTool(context);
            
            Feed feedSource = null;
            if (feedType.equals("IssueFeed")){
                String issueId = parser.getString(ISSUE_ID_KEY);                
                if(issueId.equals("")){
                    throw new IllegalArgumentException("Issue ID is missing.  Should be appended like: /issueId/xxx");
                }            	
            	Issue issue = IssueManager.getIssueById(issueId);
            	feedSource = new IssueFeed(issue,scarabLink, getLocalizationTool(context));
            }
            else {
            	throw new Exception("Couldn't find feed for type:" + feedType);
            }
            SyndFeed feed = feedSource.getFeed();

            feedFormat = (feedFormat!=null) ? feedFormat : DEFAULT_FEED_FORMAT;
            feed.setFeedType(feedFormat);

            
            SyndFeedOutput output = new SyndFeedOutput();
            output.output(feed,writer);
        }
        catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }        
        catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }      		
	}
              
// in java/org/tigris/scarab/screens/entry/Wizard1.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception
    {
        Issue newIssue = scarabR.getReportingIssue();
        IssueType issueType = newIssue.getIssueType();
        RModuleIssueType rmit = newIssue.getModule()
            .getRModuleIssueType(issueType);
        String name;
        if (rmit == null)
        {
            name = issueType.getName();
            Log.get().warn("Used global name of issueType, " + name + 
                           ", but the module version should be available.");
        }
        else
        {
            name = rmit.getDisplayName();
        }

        return l10n.format("EnterNewIssueType", name);
    }
              
// in java/org/tigris/scarab/screens/DataExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        String format = ScarabUtil.findValue(data, ExportFormat.KEY_NAME);

       log.debug("Export for format: " + format);
        
        // look for a configuration toggle for the encoding to which to
        // export.  TODO : make this per request configurable (with a per-
        // language default) to allow use of scarab in a multilingual 
        // environment.
        if (ExportFormat.EXCEL_FORMAT.equalsIgnoreCase(format))
        {
            data.getResponse().setContentType("application/vnd.ms-excel");
        }
        else
        {
            // we want to set a charset on the response -- so clients
            // can detect it properly -- if we have a known encoding
            String encoding = getEncodingForExport(data);
            String contentType = "text/tab-separated-values";
            if (encoding != null && !encoding.equals(""))
            {
                contentType = contentType + "; charset=" + encoding;
            }
            data.getResponse().setContentType(contentType);
        }
        // Since we're streaming the TSV content directly from our
        // data source, we don't know its length ahead of time.
        //data.getResponse().setContentLength(?);
        
        // FIXME: Provide work hooks here...
        //TSVPrinter printer = new TSVPrinter(data.getResponse().getWriter());
        //writeHeading(printer, mitlist, l10n, rmuas);
        //writeRows(printer, mitlist, l10n, scarabR, rmuas);

        // Above we sent the response, so no target to render
        data.setTarget(null);
    }
              
// in java/org/tigris/scarab/screens/AssignIssue.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
        String[] issueIdList = data.getParameters().getStrings("issue_ids");
        String singleIssue = data.getParameters().getString("issueId");
        Integer size = null;
        if (issueIdList == null) 
        {
            size = new Integer(0);
        }
        else if (singleIssue != null)
        {
            size = new Integer(1);
        }
        else 
        {
            size = new Integer(issueIdList.length);
        }
        return l10n.format("AssignUsersWithThisIssue", size);
    }
              
// in java/org/tigris/scarab/screens/ConfigureIssueList.java
protected void doBuildTemplate(RunData data, TemplateContext context) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        List attributes = scarabR.getAllValidIssueListAttributes();
        for (Iterator it = RModuleUserAttribute.internalAttributes.iterator(); it.hasNext(); )
        {
            attributes.add(it.next());
        }
        context.put("attributepreferences", scarabR.getRModuleUserAttributes());
        context.put("attributes", attributes);
        super.doBuildTemplate(data, context);
    }
              
// in java/org/tigris/scarab/screens/MoveIssue.java
protected String getTitle(ScarabRequestTool scarabR,
            ScarabLocalizationTool l10n)
    	throws Exception
    {
    	return getTitle(scarabR, l10n, data, context);
    }
              
// in java/org/tigris/scarab/screens/MoveIssue.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception
    {
        String title = null;
        try
        {
            String action = ((IntakeTool) context.get("intake"))
                .get("MoveIssue").getDefault().get("Action").toString();
            String l10nKey = getKey();
            if (COPY.equals(action))
            {
                title = l10n.format(l10nKey, COPY_CHOICE);
            }
            else if (MOVE.equals(action))
            {
                title = l10n.format(l10nKey, MOVE_CHOICE);
            }
            else 
            {
                scarabR.setAlertMessage(l10n.get("NoActionSpecified"));
                setTarget(data, "ViewIssue.vm");
            }
        }
        catch (Exception e)
        {
            title = "Error; Copy or Move?";
            Log.get().warn("Error determining title", e);
        }
        return title;
    }
              
// in java/org/tigris/scarab/screens/MoveIssue.java
protected void doBuildTemplate(RunData data, TemplateContext context)
    	throws Exception
    {
    	this.data = data;
    	this.context = context;
    	super.doBuildTemplate(data, context);
    }
              
// in java/org/tigris/scarab/screens/notifications/NotificationList.java
protected void doBuildTemplate(RunData data, TemplateContext context) throws Exception
    {
        List notifs = NotificationStatusManager
                .getNotificationsFor((ScarabUser) data.getUser());
        OrderedMap issueSets = new ListOrderedMap();
        for (Iterator it = notifs.iterator(); it.hasNext(); )
        {
            NotificationStatus notif = (NotificationStatus)it.next();
            Issue issue = notif.getActivity().getIssue();
            OrderedMap setActivities = (OrderedMap)issueSets.get(issue);
            if (null == setActivities)
            {
                setActivities = new ListOrderedMap();
                issueSets.put(issue, setActivities);
            }
            Activity act = notif.getActivity();
            ActivitySet set = act.getActivitySet();
            List notifications = (List)setActivities.get(set);
            if (null == notifications)
            {
                notifications = new ArrayList();
                setActivities.put(set, notifications);
            }
            notifications.add(notif);
        }
        context.put("notificationStructure", issueSets);
        super.doBuildTemplate(data, context);
    }
              
// in java/org/tigris/scarab/feeds/IssueFeed.java
public SyndFeed getFeed() throws IOException, FeedException, TorqueException, Exception {

        SyndFeed feed = new SyndFeedImpl();
       
        String title = issue.getUniqueId() + ": " + issue.getDefaultText();
        feed.setTitle(title);
        String link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
        feed.setLink(link);
        feed.setDescription(title);

        List entries = new ArrayList();
        List allActivities = issue.getActivity(true);
        

        for (Iterator i = allActivities.iterator(); i.hasNext();) {
            SyndEntry entry;
            SyndContent description;
            
            Activity activity = (Activity)i.next();
            
            ActivitySet activitySet = activity.getActivitySet();
            Date date =activitySet.getCreatedDate();
            entry = new SyndEntryImpl();

            entry.setPublishedDate(date);
            
            description = new SyndContentImpl();
            description.setType("text/html");
            
            String desc =
                  "<b>Description:</b>" + activity.getDisplayName(this.l10nTool) +"<br/>"
                + "<b>New:</b>" + activity.getNewValue(this.l10nTool) +"<br/>"
                + "<b>Old:</b>" + activity.getOldValue(this.l10nTool) +"<br/>"
                + "<b>Reason:</b>" + activitySet.getCommentForHistory(issue) +"<br/>";
            
            entry.setAuthor(activitySet.getCreator().getName());

            description.setValue(desc.toString());            

			String entryTitle = createEntryTitle(activity);
            entry.setTitle(entryTitle);
            
            entry.setDescription(description);
            
            //The hashCode is a cheap trick to have a unique link tag in the RSS feed
            //to help those reader as ThunderBird that use the link to check for new items
            entry.setLink(link+"?hash="+entry.hashCode());
            
            entries.add(entry);
        }
     

        feed.setEntries(entries);
        
        return feed;
    }
              
// in java/org/tigris/scarab/feeds/QueryFeed.java
public SyndFeed getFeed() throws Exception, TorqueException, DataSetException, TurbineSecurityException
    {
        SyndFeed feed = new SyndFeedImpl();
        feed.setTitle(query.getName());
        String link = scarabLink.setAction("Search").addPathInfo("go",query.getQueryId()).toString();
        feed.setLink(link);
        feed.setDescription(query.getDescription());
        List entries = new ArrayList();
        for(Iterator i = results.iterator(); i.hasNext();)
        {
            SyndEntry entry = new SyndEntryImpl();
            SyndContent description = new SyndContentImpl();
            QueryResult queryResult = (QueryResult)i.next();
            String title = queryResult.getUniqueId();
            entry.setTitle(title);
            
            Issue issue = IssueManager.getInstance(Long.valueOf(queryResult.getIssueId()));

            link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
            entry.setLink(link);

            Date publishedDate = null;
            if(issue.getModifiedDate()!= null){
                publishedDate = issue.getModifiedDate();
            }
            else {
                publishedDate = issue.getCreatedDate();
            }
            entry.setPublishedDate(publishedDate);

            description = new SyndContentImpl();
            description.setType("text/html");
            String desc = "";
            Iterator avIteratorCSV = queryResult.getAttributeValuesAsCSV().iterator();
            Iterator avIterator = query.getMITList().getAllRModuleUserAttributes().iterator();
            while (avIterator.hasNext())
            {
                String value = (String)avIteratorCSV.next();
                RModuleUserAttribute av = (RModuleUserAttribute)avIterator.next();
                desc = desc + "<b>" + av.getAttribute().getName()+":</b>" + value +"<br/>";
            }
            description.setValue(ScarabUtil.filterNonXml(desc));

            entry.setDescription(description);
            entries.add(entry);
        }
        feed.setEntries(entries);
        feed.setFeedType(format);
        return feed;
    }
              
// in java/org/tigris/scarab/components/TorqueComponent.java
public void initialize()
            throws Exception
    {
        getLogger().debug("initialize()");
        Torque.init(
            Turbine.getConfiguration()
        );
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        String next = ScarabUtil.findValue(data, "next");
        if (StringUtils.isNotEmpty
            (ScarabUtil.findValue(data, ExportFormat.KEY_NAME)))
        {
            // Send to the IssueListExport screen (which actually
            // has no corresponding Velocity template).
            setTarget(data, "IssueListExport.vm");
        }
        else if (StringUtils.isNotEmpty(next))
        {
            // Redirect to View, Assign, or Move/Copy
            List issueIds = null;
            ScarabUser user = (ScarabUser) data.getUser();
            if (next.indexOf("All") > -1)
            {
                // all issues are selected
                issueIds = getAllIssueIds(data);
            }
            else
            {
                // get issues select by user
                issueIds = getSelected(data);
            }


            if (issueIds.size() < 1)
            {
                scarabR.setAlertMessage(L10NKeySet.SelectIssues);
                return;
            }

            List modules = ModuleManager.getInstancesFromIssueList(
                scarabR.getIssues(issueIds));
            if (next.indexOf("assign") > -1)
            {
                if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, modules))
                {
                    if (issueIds.size() <= ScarabConstants.ISSUE_MAX_ASSIGN)
                    {
                        scarabR.resetAssociatedUsers();
                        setTarget(data, "AssignIssue.vm");
                    }
                    else
                    {
                        L10NMessage msg = new L10NMessage
                        (
                            L10NKeySet.IssueLimitExceeded,
                            String.valueOf(ScarabConstants.ISSUE_MAX_ASSIGN)
                        );
                        scarabR.setAlertMessage(msg);
                        return;
                    }
                }
                else
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                    return;
                }
            }
            else if (next.indexOf("view") > -1)
            {
                if (user.hasPermission(ScarabSecurity.ISSUE__VIEW, modules))
                {
                    if (issueIds.size() <= ScarabConstants.ISSUE_MAX_VIEW)
                    {
                        setTarget(data, "ViewIssueLong.vm");
                    }
                    else
                    {
                        L10NMessage msg = new L10NMessage
                        (
                            L10NKeySet.IssueLimitExceeded,
                            String.valueOf(ScarabConstants.ISSUE_MAX_VIEW)
                        );
                        scarabR.setAlertMessage(msg);
                        return;
                    }
                }
                else
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                    return;
                }
            }
            else if (next.indexOf("copy") > -1)
            {
                if (user.hasPermission(ScarabSecurity.ISSUE__ENTER, modules))
                {
                    if (issueIds.size() <= ScarabConstants.ISSUE_MAX_COPY)
                    {
                        data.getParameters().add("mv_0rb", "copy");
                        setTarget(data, "MoveIssue.vm");
                    }
                    else
                    {
                        L10NMessage msg = new L10NMessage
                        (
                            L10NKeySet.IssueLimitExceeded,
                            String.valueOf(ScarabConstants.ISSUE_MAX_COPY)
                        );
                        scarabR.setAlertMessage(msg);
                        return;
                    }
                }
                else
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
            }
            else if (next.indexOf("move") > -1)
            {
                if (user.hasPermission(ScarabSecurity.ISSUE__MOVE, modules))
                {
                    if (issueIds.size() <= ScarabConstants.ISSUE_MAX_MOVE)
                    {
                        data.getParameters().add("mv_0rb", "move");
                        setTarget(data, "MoveIssue.vm");
                    }
                    else
                    {
                        L10NMessage msg = new L10NMessage
                        (
                            L10NKeySet.IssueLimitExceeded,
                            String.valueOf(ScarabConstants.ISSUE_MAX_MOVE)
                        );
                        scarabR.setAlertMessage(msg);
                        return;
                    }
                }
                else
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
            }
        }
        else
        {
            String template = data.getParameters()
                .getString(ScarabConstants.NEXT_TEMPLATE,
                           getIssueListTarget());
            setTarget(data, template);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doSearch(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        String queryString = getQueryString(data);        
        setRecentQuery(queryString);
        translateSortorder(data, queryString);

        doPerform(data, context);
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doRedirecttosavequery(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data, context);
        if (data.getParameters().getString("refine") != null)
        {
            setRecentQuery(getQueryString(data));
        }

        if (scarabR.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES))
        {
            setTarget(data, "SaveQuery.vm");
        }
        else 
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doRedirecttocrossmodulelist(RunData data, TemplateContext context)
         throws Exception
    {
        data.getParameters().setString("queryString", getQueryString(data));
        setTarget(data, "IssueTypeList.vm");
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doSavequery(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data, context);
        
        if (!scarabR.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

               
        Module module = scarabR.getCurrentModule();
        Query query = scarabR.getQuery();
        Group queryGroup = intake.get("Query",
                                      query.getQueryKey());

        Field name = queryGroup.get("Name");
        name.setRequired(true);
        data.getParameters().setString("queryString", getQueryString(data));

        if (intake.isAllValid())
        {
            queryGroup.setProperties(query);
            query.setScarabUser(user);
            MITList currentList = user.getCurrentMITList();
            if (currentList == null)
            {
                scarabR.setAlertMessage(L10NKeySet.NoIssueTypeList);
                return;
            }
            else
            {
                //
                // Get hold of all the attributes that apply to
                // this list. We will have to copy them manually
                // to the new list because MITList.copy() won't
                // do it for us.
                //
                List commonAttributes = 
                    currentList.getCommonRModuleUserAttributes();
                
                // associate the query with a new list, the current
                // implementation does not allow for multiple queries to
                // work from the same MITList and this guarantees they
                // will not accidently be linked.
                currentList = currentList.copy();
                if (currentList.isModifiable())
                {
                    currentList.setName(null);
                }
                
                //
                // Copy the attributes from the original list
                // to the new one.
                //
                for (Iterator iter = commonAttributes.iterator();
                              iter.hasNext(); )
                {
                    RModuleUserAttribute attr =
                            (RModuleUserAttribute) iter.next();
                    
                    //
                    // When we copy the attribute, we don't actually
                    // want to keep the list ID because that refers
                    // to the old list rather than the new one. So
                    // we just clear it - when the list is saved the
                    // correct list ID will automatically be set for
                    // the attribute.
                    //
                    RModuleUserAttribute newAttr = attr.copy();
                    newAttr.setListId(null);
                    newAttr.setUserId(user.getUserId());
                    currentList.addRModuleUserAttribute(newAttr);
                }
                
                //
                // Update the query to use the new MIT list.
                //
                query.setMITList(currentList);
                if (!currentList.isSingleModule())
                {
                    query.setModule(null);
                    query.setScopeId(Scope.PERSONAL__PK);
                }
            }

            ScarabUser[] userList =
                module.getUsers(ScarabSecurity.ITEM__APPROVE);
            if (checkForDupes(query, user, module))
            {
                scarabR.setAlertMessage(L10NKeySet.DuplicateQueryName);
            }
            else if (Scope.MODULE__PK.equals(query.getScopeId())
                 && user.hasPermission(ScarabSecurity.ITEM__APPROVE, module)
                 && (userList == null || userList.length == 0))
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.NoApproverAvailable, module.getName());
                scarabR.setAlertMessage(msg);
            }
            else
            {
                try
                {
                    query.saveAndSendEmail(user, module, context);
                }
                catch(Exception e)
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneral,e);
                    scarabR.setAlertMessage(msg);
                }
                scarabR.resetSelectedUsers();
                if (query.canEdit(user))
                {
                    scarabR.setConfirmMessage(DEFAULT_MSG);
                }
                else
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.NotifyPendingApproval,L10NKeySet.Query);
                    scarabR.setInfoMessage(msg);
                    //scarabR.setInfoMessage(
                    //        l10n.format("NotifyPendingApproval",
                    //        l10n.get("Query").toLowerCase()));
                }
                setTarget(data, "QueryList.vm");
            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public boolean doEditqueryinfo(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        boolean success = false;

        Module module = scarabR.getCurrentModule();
        Query query = scarabR.getQuery();
        Group queryGroup = intake.get("Query",
                                      query.getQueryKey());
        queryGroup.get("Name").setRequired(true);
        if (intake.isAllValid())
        {
            queryGroup.setProperties(query);
            if (checkForDupes(query, user, module))
            {
                scarabR.setAlertMessage(L10NKeySet.DuplicateQueryName);
            }
            else
            {
                query.saveAndSendEmail(user, module, context);
                success = true;
                if (query.canEdit(user))
                {
                    scarabR.setConfirmMessage(L10NKeySet.QueryModified);
                }
                else
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.NotifyPendingApproval,L10NKeySet.Query);
                    scarabR.setInfoMessage(msg);
                    //scarabR.setInfoMessage(
                    //                l10n.format("NotifyPendingApproval",
                    //                l10n.get("Query").toLowerCase()));
                    setTarget(data, data.getParameters().getString(
                                    ScarabConstants.CANCEL_TEMPLATE));
                }

            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doPreparequery(RunData data, TemplateContext context)
         throws Exception
    {        
        setup(data, context);
        Query query = scarabR.getQuery();
        user.setCurrentMITList(query.getMITList());
        /* TODO! It would be better if the query could be viewed or
           edited without having to pass the query data via request parameters
           as would be done with the code below, but it caused a few bugs like
           losing users and maybe the mitlist, so revisit this later.
        user.setMostRecentQuery(query.getValue());
        */
        setRecentQuery(getQueryString(data));
        scarabR.resetSelectedUsers();
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doEditstoredquery(RunData data, TemplateContext context)
         throws Exception
    {        
        setup(data, context);        

        Query query = scarabR.getQuery();
        String newValue = getQueryString(data);
        query.setValue(newValue);
        query.saveAndSendEmail((ScarabUser)data.getUser(), 
                 scarabR.getCurrentModule(), context);
        scarabR.resetSelectedUsers();
        setRecentQuery(newValue);
    }
              
// in java/org/tigris/scarab/actions/Search.java
private void doRunstoredquery(RunData data, TemplateContext context)
         throws Exception
    {
        //setup(data, context);
        // Set current query to the stored query
        Query query = scarabR.getQuery();
        MITList mitList = query.getMITList();
        user.setCurrentMITList(mitList);
        if (mitList != null)
        {
            mitList.setScarabUser(user);
        }
        setRecentQuery(query.getValue());
        
        translateSortorder(data, query.getValue());

        setTarget(data, getIssueListTarget());
    }
              
// in java/org/tigris/scarab/actions/Search.java
private void translateSortorder(RunData data, String queryString) throws Exception
    {
        // Add 'sortColumn', 'sortPolarity' and 'resultsPerPage'
        // to the RunData parameters. This ensures that when the
        // user runs a saved query, the resulting issue list is
        // displayed with that query's settings. 
        //
        // TODO remove translateSortorder
        // this method is just a hack
        // instead of translating between different parameter names
        // the sortorder-parameter should have the same name, 
        // in the edit-query-screens as well as in the issue list
        StringValueParser parser = ScarabUtil.parseURL(queryString);
        
        if (parser.containsKey("resultsperpage")) {
            data.getParameters().add("resultsperpage",
                                     parser.getInt("resultsperpage"));
        }
        
        if (parser.containsKey("searchsai")) {
            data.getParameters().add("sortColumn",
                                     parser.getInt("searchsai"));
        }
        
        if (parser.containsKey("searchsp")) {
            data.getParameters().add("sortPolarity",
                                     parser.getString("searchsp"));
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doSelectquery(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        String go = data.getParameters().getString("go");
        

        if (go != null && go.length() > 0)
        {
            // if the string is a number, then execute
            // doRunstoredquery()
            if (StringUtils.isNumeric(go))
            {
                data.getParameters().setString("queryId", go);
                doRunstoredquery(data, context);
            }
            else if (go.startsWith("newQuery"))
            {
                // do this to load last mitlist
                user.getMostRecentQuery();
                if (go.endsWith("IT")) 
                {
                    user.setCurrentMITList(null);
                }
                // reset selected users map
                scarabR.resetSelectedUsers();                
                setTarget(data, user.getQueryTarget());
            }
            else if (go.equals("mostRecent"))
            {
                setTarget(data, getIssueListTarget());
            }
            else if (go.equals("myIssuesThisModule"))
            {
                Module module = user.getCurrentModule();
                user.setCurrentMITList(MITListManager
                    .getSingleModuleAllIssueTypesList(module, user));

                String userId = user.getQueryKey();
                StringBuffer sb = new StringBuffer(26 + 2*userId.length());
                String query = sb.append("&user_list=").append(userId)
                    .append("&user_attr_").append(userId).append("=any")
                    .toString();
                setRecentQuery(query);
                setTarget(data, getIssueListTarget());
            }
            else if (go.equals("myIssuesAllModules"))
            {
                user.setCurrentMITList(MITListManager.getAllModulesAllIssueTypesList(user));

                String userId = user.getQueryKey();
                StringBuffer sb = new StringBuffer(26 + 2*userId.length());
                String query = sb.append("&user_list=").append(userId)
                    .append("&user_attr_").append(userId).append("=any")
                    .toString();
                setRecentQuery(query);
                setTarget(data, getIssueListTarget());
            }
            else if (go.equals("quickSearch"))
            {
                String searchString = data.getParameters().getString("searchString");
                if(searchString==null || searchString.equals(""))
                {
                    scarabR.setAlertMessage(L10NKeySet.QueryParserError);
                }
                else
                {
                    Module module = user.getCurrentModule();
                    MITList mitList = MITListManager.getSingleModuleAllIssueTypesList(module,user);
                    user.setCurrentMITList(mitList); 
                               
                    Map attributeMap = new Hashtable();
                    List attributes = module.getAllAttributes();
                    for( int aindex = 0; aindex < attributes.size(); aindex++)
                    {
                        Attribute attribute = (Attribute) attributes.get(aindex);
                        AttributeType type = attribute.getAttributeType();
                        String typeName = type.getName();
                        if(typeName.equals("string") || typeName.equals("long-string"))
                        {
                            if (attribute.isTextAttribute())
                            {
                                Integer id = attribute.getAttributeId();
                                if(attributeMap.get(id) == null)
                                {
                                    attributeMap.put(id,attribute);
                                }
                            }
                        }
                    }
                    quickSearch(searchString, attributeMap, user);
                }
                setTarget(data, getIssueListTarget());
            }
            else if (go.equals("privateQueries")
                   ||go.equals("publicQueries"))
            {
                setTarget(data,"QueryList.vm");
            }
            else
            {
                setTarget(data, go);
            }
        }
        else
        {
            // set the next template
            String nextTemplate = data.getParameters()
                .getString(ScarabConstants.NEXT_TEMPLATE, 
                Turbine.getConfiguration()
                           .getString("template.homepage", "Index.vm"));
            setTarget(data, nextTemplate);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doRefinequery(RunData data, TemplateContext context)
         throws Exception
    {        
        context.put("refine", "true");
        setTarget(data, "AdvancedQuery.vm");    
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = doEditqueryinfo(data, context);
        if (success)
        {
            doEditstoredquery(data, context);
            doCancel(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public static String getQueryString(RunData data) throws Exception
    {
        String queryString = data.getParameters().getString("queryString");
        if (queryString == null) 
        {
            StringBuffer buf = new StringBuffer();
            Object[] keys =  data.getParameters().getKeys();
            for (int i =0; i<keys.length; i++)
            {
                String key = keys[i].toString();
                if (key.startsWith("attv") || key.startsWith("search")
                    || key.startsWith("intake") || key.startsWith("user_attr")
                    || key.startsWith("user_list") || key.startsWith("results")
                    || "format".equalsIgnoreCase(key))
                {
                    String[] values = data.getParameters().getStrings(key);
                    for (int j=0; j<values.length; j++)
                    {
                        String value = values[j];
                        if (StringUtils.isNotEmpty(value))
                        {
                            buf.append('&').append(key);
                            buf.append('=').append(ScarabUtil.urlEncode(value));
                        }
                    }
                }
            }

            queryString = (buf.length() == 0
                           ? ((ScarabUser)data.getUser()).getMostRecentQuery()
                           : buf.toString());
        }
        if(queryString == null)
        {
            queryString="";
        }
        return queryString.toLowerCase();
    }
              
// in java/org/tigris/scarab/actions/Search.java
private boolean checkForDupes(Query query, ScarabUser user, Module module)
        throws Exception
    {
        boolean areThereDupes = false;
        List prevQueries = new ArrayList();
        if (query.getScopeId().equals(Scope.MODULE__PK))
        {
            prevQueries.addAll(QueryPeer.getModuleQueries(module));
        }
        else
        {
            // Add personal queries only, not all module-level queries created
            // by this user.
            for (Iterator i = QueryPeer.getUserQueries(user).iterator(); i.hasNext(); ) 
            {
                Query q = (Query)i.next();
                if (q.getModule() == null)
                {
                    prevQueries.add(q);
                }
            }
        }
        if (prevQueries != null && !prevQueries.isEmpty())
        {
            Long pk = query.getQueryId();
            String name = query.getName();
            for (Iterator i = prevQueries.iterator(); 
                 i.hasNext() && !areThereDupes;)
            {
                Query q = (Query)i.next();
                areThereDupes = (pk == null || !pk.equals(q.getQueryId())) &&
                    name.trim().toLowerCase().equals(
                        q.getName().trim().toLowerCase());
            }
        }
        return areThereDupes;
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doGotoeditlist(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        Map userMap = user.getSelectedUsersMap();
        if (userMap == null || userMap.size() == 0)
        {
            userMap = new HashMap();
            loadUsersFromUserList(data, userMap);
        }
        data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE,
                                       getCurrentTemplate(data));
        setRecentQuery(getQueryString(data));
        IssueSearch search = scarabR.getPopulatedSearch();
        if (search != null)
        {
            setTarget(data, "UserList.vm");
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doAddusers(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data, context);
        
        Map userMap = user.getSelectedUsersMap();
        if (userMap == null)
        {
            userMap = new HashMap();
        }        
        String[] userIds = params.getStrings(ADD_USER);
        if (userIds != null && userIds.length > 0) 
        {
            for (int i =0; i<userIds.length; i++)
            {
                String userId = userIds[i];
                String[] attrIds = params.getStrings("user_attr_" + userId);
                if (attrIds != null) 
                {
                    for (int j=0; j<attrIds.length; j++) 
                    {
                        addAttributeToMap(userMap, userId, attrIds[j], context);
                    }
                }
            } 
            user.setSelectedUsersMap(userMap);
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereAdded);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doAdduserbyusername(RunData data, TemplateContext context)  
        throws Exception
    {
        setup(data, context);

        String userName = params.getString(ADD_USER_BY_USERNAME);
        String attrId = params.getString("add_user_attr");

        Map userMap = user.getSelectedUsersMap();
        if (userMap == null || userMap.size() == 0)
        {
            userMap = new HashMap();
            loadUsersFromUserList(data, userMap);
        }

        String userId = null;
       
        if(IssueSearch.SEARCHING_USER_KEY.equalsIgnoreCase(userName))
        {
            userId=userName;
        }
        else
        {
            ScarabUser newUser = scarabR.getUserByUserName(userName);        
            if (newUser != null)
            {
                userId = newUser.getUserId().toString();
            }
        }
    
        if (userId!=null)
        {
            addAttributeToMap(userMap, userId, attrId, context);
            user.setSelectedUsersMap(userMap);
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereAdded);
        }
        else
        {
            scarabR.setAlertMessage(L10NKeySet.UserNotPossibleAssignee);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doRemoveusers(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
         
        Map userMap = user.getSelectedUsersMap();
        if (userMap == null || userMap.size() == 0)
        {
            userMap = new HashMap();
            loadUsersFromUserList(data, userMap);
        }
        
        String[] userAttrIds =  params.getStrings(SELECTED_USER);
        if (userAttrIds != null && userAttrIds.length > 0) 
        {
            for (int i =0; i<userAttrIds.length; i++)
            {
                String userAttrId = userAttrIds[i];
                int delimPos = userAttrId.indexOf('_');
                String userId = userAttrId.substring(0, delimPos);
                Set currentAttrIds = (Set)userMap.get(userId);
                if (currentAttrIds.size() == 1) 
                {
                    userMap.remove(userId);                    
                }
                else 
                {
                    currentAttrIds.remove(userAttrId.substring(delimPos+1));
                }
            }
            user.setSelectedUsersMap(userMap);
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereRemoved);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doUpdateusers(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        
        Map userMap = user.getSelectedUsersMap();
        
        String[] userAttrIds =  params.getStrings(SELECTED_USER);
        if (userAttrIds != null && userAttrIds.length > 0) 
        {
            for (int i =0; i<userAttrIds.length; i++)
            {
                String userAttrId = userAttrIds[i];
                int delimPos = userAttrId.indexOf('_');
                String userId = userAttrId.substring(0, delimPos);
                String oldAttrId = userAttrId.substring(delimPos+1);
                String newAttrId = params
                    .getString("user_attr_" + userAttrId);
                if (!oldAttrId.equals(newAttrId)) 
                {
                    List currentAttrIds = (List)userMap.get(userId);
                    if (ANY.equals(newAttrId)) 
                    {
                        currentAttrIds.clear();
                        currentAttrIds.add(ANY);
                    }
                    else 
                    {
                        for (int j=currentAttrIds.size()-1; j>=0; j--) 
                        {
                            if (currentAttrIds.get(j).equals(oldAttrId)) 
                            {
                                currentAttrIds.set(j, newAttrId);
                                break;
                            }
                        }
                    }
                }                
            }
            user.setSelectedUsersMap(userMap);
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereModified);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void loadUsersFromUserList(RunData data, Map userMap)
        throws Exception
    {
        ParameterParser params = data.getParameters();
        String[] userList = params.getStrings(USER_LIST);
        if (userList !=null && userList.length > 0)
        {
            for (int i =0;i<userList.length;i++)
            {
                String userId = userList[i];
                String[] attrIds = params.getStrings("user_attr_" + userId);
                if (attrIds != null) 
                {
                    for (int j=0; j<attrIds.length; j++) 
                    {
                        addAttributeToMap(userMap, userId, attrIds[j],
                                          getTemplateContext(data));
                    }
                }
            }
            ((ScarabUser)data.getUser()).setSelectedUsersMap(userMap);
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
public void doSetquerytarget(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        
        MITList mitlist = user.getCurrentMITList();
        if (mitlist != null && mitlist.isSingleModuleIssueType()) 
        {
            user.setSingleIssueTypeQueryTarget(
                mitlist.getIssueType(), data.getTarget());
        }
        else 
        {
        
            if (mitlist == null) 
            {
                scarabR.setAlertMessage(L10NKeySet.NoIssueTypeList);
            }
            else 
            {
                scarabR.setAlertMessage(L10NKeySet.IssueTypeListMoreThanOne);
            }
            

            Log.get().warn(
                "Issue type list did not contain one and only one element.");
        }
    }
              
// in java/org/tigris/scarab/actions/Search.java
private void setup(RunData data, TemplateContext context) throws Exception{
        l10n = getLocalizationTool(context);
        scarabR = getScarabRequestTool(context);
        intake = getIntakeTool(context);
        params = data.getParameters();
        user = (ScarabUser)data.getUser();
    }
              
// in java/org/tigris/scarab/actions/ForgotPassword.java
public void doForgotpassword(RunData data, TemplateContext context)
        throws Exception
    {
        data.setACL(null);
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid() && forgotPassword(data, context))
        {
            setTarget(data, "Login.vm");
        }
    }
              
// in java/org/tigris/scarab/actions/ForgotPassword.java
public boolean forgotPassword(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        
        Group password = intake.get("ForgotPassword", IntakeTool.DEFAULT_KEY);
        String username = password.get("Username").toString();
        
        ScarabUser user = null;
        try
        {
            user = ScarabUserManager.getInstance(username);
            
            String tempPassword = PasswordGenerator.generate();
            
            // first we need to save the user out of the session
            user.setPasswordExpire(Calendar.getInstance());
            user.setHasLoggedIn(Boolean.FALSE);
            data.setUser(user);
            data.save();

            // set the password to a temporary value then set the password to
            // expire now, forcing the user to change their password after login.
            TurbineSecurity.forcePassword(user, tempPassword);

            sendNotificationEmail(context, user, tempPassword);
            
            // create confirmation message
            Localizable msg = new L10NMessage(L10NKeySet.PasswordResetMessage,
                                              user.getEmail()); 
            getScarabRequestTool(context).setConfirmMessage(msg);
        }
        catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
        return true;
    }
              
// in java/org/tigris/scarab/actions/ForgotPassword.java
public static void sendNotificationEmail(TemplateContext context, ScarabUser user, String tempPassword) throws Exception
    {
        // place the password
        // in the context for use in the email template.
        context.put("password", tempPassword);

        Email te = new Email();
        
        // Retrieve the charset to be used for the Email.
        ScarabLocalizationTool l10n = (new ForgotPassword()).getLocalizationTool(context);
        Locale locale = l10n.getPrimaryLocale();
        String charset = Email.getCharset(locale);
        te.setCharset(charset);
        
        
        te.setContext(new ContextAdapter(context));
        te.addTo(user.getEmail(), user.getFirstName() + " " + user.getLastName());
        te.setFrom(
            Turbine.getConfiguration()
                .getString("scarab.email.forgotpassword.fromAddress",
                           "help@localhost"),
            Turbine.getConfiguration()
                .getString("scarab.email.forgotpassword.fromName",
                           "Scarab System"));
        te.setSubject(
            l10n.get(L10NKeySet.ForgotPasswordEmailSubject));
        te.setTemplate(
            Turbine.getConfiguration()
                .getString("scarab.email.forgotpassword.template",
                           "email/ForgotPassword.vm"));
        te.send();
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
private void setup(RunData data, TemplateContext context) throws Exception{
        l10n = getLocalizationTool(context);
        scarabR = getScarabRequestTool(context);
        report = scarabR.getReport();
        intake = getIntakeTool(context);
        params = data.getParameters();
        user = (ScarabUser)data.getUser();
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSaveinfo(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable((ScarabUser)data.getUser())) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");                        
        }
        else if (intake.isAllValid()) 
        {
            Group intakeReport = getIntakeReportGroup(intake, report);
            if (intakeReport != null) 
            {   
                intakeReport.setValidProperties(report);

                if (report.isReadyForCalculation()) 
                {
                    String msg = report.isNew() ? 
                           l10n.get(L10NKeySet.ReportUpdated) :
                           l10n.get(L10NKeySet.ReportUpdatedNotSaved);
                    scarabR.setConfirmMessage(msg);
                    setTarget(data, "reports,Info.vm");     
                }
                else 
                {
                    String msg = report.isNew() ? 
                           l10n.get("ReportUpdatedPleaseAddRowAndColumnCriteria") :
                           l10n.get("ReportUpdatedNotSavedPleaseAddRowAndColumnCriteria");
                    scarabR.setConfirmMessage(msg);
                    setTarget(data, "reports,AxisConfiguration.vm");
                }
            }
            else 
            {
                // FIXME! i don't know that the intakeReport should ever be 
                // null, but since the conditional was here, don't fail silently
                scarabR.setAlertMessage(
                		L10NKeySet.ThisShouldNotHappenPleaseContactAdmin);
                setTarget(data, "reports,Info.vm");
            }            
        }
        else 
        {
            scarabR.setAlertMessage(
            		L10NKeySet.InvalidData);
            setTarget(data, "reports,Info.vm");            
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSelectheading(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        // the form will carry over the selected heading. just make sure
        // to remove old intake data
        
        intake.removeAll();
        // give the user a message if they are already on the selected
        // heading, in the event they are confused.
        
        int level = params.getInt("heading", -1);
        int prevLevel = params.getInt("prevheading", -2);
        if (level == prevLevel) 
        {
            getScarabRequestTool(context).setInfoMessage(
                getLocalizationTool(context)
                .format("AlreadyEditingSelectedHeading", new Integer(level+1)));
        }        
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSettype(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        int type = params.getInt("headingtype", 0);

        // remove any old data
        if (level != -1) 
        {
            
            ReportDefinition reportDefn = report.getReportDefinition();
            ReportAxis reportAxis = reportDefn.getAxis(axis);
            ReportHeading heading = reportAxis.getHeading(level);
            int currentType = heading.calculateType();
            if (type != currentType) 
            {            
                if (currentType == 2 && 
                    !reportDefn.allowMoreHeadings(reportAxis)) 
                {
                    scarabR.setAlertMessage(L10NKeySet.ThisAxisMustBeDatesUnlessHeadingsAreRemoved);
                    params.setString("headingtype", "2");
                }
                else 
                {
                    LocalizationKey msg;
                    if (heading.size() > 0) 
                    {
                        heading.reset();
                        msg = L10NKeySet.HeadingTypeChangedOldDataDiscarded;
                    }
                    else
                    {
                        msg = L10NKeySet.HeadingTypeChanged;
                    }
                    scarabR.setConfirmMessage(msg);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAddoptions(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable((ScarabUser)data.getUser())) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");                        
        }
        else if (intake.isAllValid()) 
        {


            int axis = params.getInt("axis", 0); // 0=row; 1=column
            int level = params.getInt("heading", -1);
            int type = params.getInt("headingtype", 0);

            // we are using an IssueSearch object to gather the data to
            // create the ReportOptionAttribute objects.
            IssueSearch search = scarabR.getNewSearch();

            // Set attribute values to search on
            for (Iterator i = search.getAttributeValuesMap(true).values().iterator(); i.hasNext();) 
            {
                AttributeValue aval = (AttributeValue)i.next();
                Group group = intake.get("AttributeValue", aval.getQueryKey());
                if (group != null) 
                {
                    group.setProperties(aval);
                }                
            }
            
            List setAttValues = search.getSetAttributeValues();
            
            ReportHeading heading = report.getReportDefinition()
                .getAxis(axis).getHeading(level);
            if (type != heading.calculateType()) 
            {
                scarabR.setAlertMessage(L10NKeySet.ChangeOfTypeMessage); 
            }
    
            // we are going to delete the old heading data and reconstruct it
            // so if there is any group info, we need to get it first
            List groups = heading.getReportGroups();
            Map optionGroupMap = null;
            if (groups != null && !groups.isEmpty()) 
            {
                optionGroupMap = new HashMap();
                for (Iterator i = groups.iterator(); i.hasNext();) 
                {
                    ReportGroup group = (ReportGroup)i.next();
                    List options = group.getReportOptionAttributes();
                    if (options != null && !options.isEmpty()) 
                    {
                        for (Iterator j = options.iterator(); j.hasNext();) 
                        {
                            optionGroupMap.put(j.next(), group);
                        }
                    }
                }
            }
            heading.reset();
            
            //convert to ReportOptionAttributes
            for (Iterator i = setAttValues.iterator(); i.hasNext();) 
            {
                AttributeValue av = (AttributeValue)i.next();
                //pull any chained values out to create a flat list
                List chainedValues = av.getValueList();
                for (Iterator j = chainedValues.iterator(); j.hasNext();) 
                {
                    ReportOptionAttribute roa = new ReportOptionAttribute();
                    Integer id = Integer.valueOf(((AttributeValue)j.next())
                                             .getOptionId().toString());
                    roa.setOptionId(id);
    
                    if (optionGroupMap == null) 
                    {
                        heading.addReportOptionAttribute(roa);
                    }
                    else 
                    {
                        ReportGroup group = 
                            (ReportGroup)optionGroupMap.get(roa);
                        if (group == null)
                        {
                            // add it to the first group
                            ((ReportGroup)groups.get(0))
                                .addReportOptionAttribute(roa);
                        }
                        else
                        {
                            group.addReportOptionAttribute(roa);
                        }
                    }
                }
            }
            if (level == -1) 
            {
                params.setString("heading", "0");
            }
    
            String msg = getLocalizedHeadingConfirmMessage(report, l10n);
            scarabR.setConfirmMessage(msg);
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAddusers(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }


        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        int type = params.getInt("headingtype", 0);
        
        // not too elegant for editing, but if groups have been defined
        // we remove them for now until the rest of the reports is 
        // more code complete !FIXME!
        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        if (type != heading.calculateType() 
            || heading.getReportGroups() != null) 
        {
            if (heading.getReportGroups() != null) 
            {
               scarabR.setAlertMessage(L10NKeySet.CouldNotMakeRequestedChange);                
            }
            heading.reset();
        }

        String[] userIds = params.getStrings(ADD_USER);
        if (userIds != null && userIds.length > 0) 
        {
            for (int i =0; i<userIds.length; i++)
            {
                String userId = userIds[i];
                ReportUserAttribute rua = new ReportUserAttribute();
                rua.setUserId(new Integer(userId));
                rua.setAttributeId(new Integer(
                    params.getString("user_attr_" + userId)));
                heading.addReportUserAttribute(rua);
            } 
            if (level == -1) 
            {
                params.setString("heading", "0");
            }

            String msg = getLocalizedHeadingConfirmMessage(report, l10n);
            scarabR.setConfirmMessage(msg);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doRemoveusers(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        int type = params.getInt("headingtype", 0);
        
        // not too elegant for editing, but if groups have been defined
        // we remove them for now until the rest of the reports is 
        // more code complete !FIXME!
        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        if (type != heading.calculateType() 
            || heading.getReportGroups() != null) 
        {
            heading.reset();
            scarabR.setAlertMessage(L10NKeySet.CouldNotMakeRequestedChange);                
        }
        else 
        {
            String[] userIds =  params.getStrings(SELECTED_USER);
            if (userIds != null && userIds.length > 0) 
            {
                for (int i =0; i<userIds.length; i++)
                {
                    String userId = userIds[i];
                    ReportUserAttribute rua = new ReportUserAttribute();
                    rua.setUserId(new Integer(userId));
                    rua.setAttributeId(new Integer(
                        params.getString("old_attr_" + userId)));
                    
                    List ruas =  heading.getReportUserAttributes();
                    if (ruas != null) 
                    {
                        ruas.remove(rua);
                    }
                }
                scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereRemoved);
            }
            else 
            {
                scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
            }
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doUpdateusers(RunData data, TemplateContext context) 
        throws Exception
    {
        
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        int type = params.getInt("headingtype", 0);
        
        // not too elegant for editing, but if groups have been defined
        // we remove them for now until the rest of the reports is 
        // more code complete !FIXME!
        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        if (type != heading.calculateType() 
            || heading.getReportGroups() != null) 
        {
            heading.reset();
            scarabR.setAlertMessage(L10NKeySet.CouldNotMakeRequestedChange);
        }
        else 
        {
            String[] userIds =  params.getStrings(SELECTED_USER);
            if (userIds != null && userIds.length > 0) 
            {
                for (int i =0; i<userIds.length; i++)
                {
                    String userId = userIds[i];
                    ReportUserAttribute rua = new ReportUserAttribute();
                    rua.setUserId(new Integer(userId));
                    rua.setAttributeId(new Integer(
                        params.getString("old_attr_" + userId)));
                    
                    List ruas =  heading.getReportUserAttributes();
                    if (ruas != null) 
                    {
                        /* this will make it hard to find dupes
                        for (Iterator i=ruas.iterator(); i.hasNext();) 
                        {
                            Object obj = i.next();
                            if (obj.equals(rua)) 
                            {
                                ((ReportUserAttribute)obj).setAttributeId();
                            }
                        }
                        */
                        ruas.remove(rua);
                    }
                    
                    rua = new ReportUserAttribute();
                    rua.setUserId(new Integer(userId));
                    rua.setAttributeId(new Integer(
                        params.getString("asso_user_{" + userId + "}")));
                    heading.addReportUserAttribute(rua);
                }
                scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereModified);
            }
            else 
            {
                scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
            }
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doRemoveheading(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        //int type = params.getInt("headingtype", 0);
        
        if (level >= 0) 
        {
            List headings = report.getReportDefinition()
                .getAxis(axis).getReportHeadings();
            headings.remove(level);
            scarabR.setConfirmMessage(L10NKeySet.HeadingRemoved); 
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoHeadingSelected);     
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doGotoeditgroups(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        
        int level = params.getInt("heading", -1);

        // user groups is not implemented
        if (level >= 0) 
        {
            int axis = params.getInt("axis", 0); // 0=row; 1=column        
            ReportHeading heading = (ReportHeading)report.getReportDefinition()
                .getAxis(axis).getReportHeadings().get(level);
            if (heading.calculateType() == 0) 
            {
                setTarget(data, "reports,EditGroups.vm");
            }
            else 
            {
                scarabR.setAlertMessage(getLocalizationTool(context)
                    .get("GroupsAreForOptionsOnly"));
            }
        }
        else
        {
            scarabR.setAlertMessage(L10NKeySet.NoHeadingSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAddheading(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }


        int axisIndex = params.getInt("axis", 0); // 0=row; 1=column
        ReportAxis axis = report.getReportDefinition().getAxis(axisIndex);
        axis.addReportHeading(new ReportHeading());
        params.setString("heading", String.valueOf(axis.getReportHeadings().size()-1));
        // remove old intake data
        Intake intake = getIntakeTool(context);
        intake.removeAll();
        scarabR.setConfirmMessage(L10NKeySet.HeadingAddedNowAddContent);
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAddgroup(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
                    
        String name = params.getString("groupname_new");
        if (name != null)
        {
            name = name.trim();
        }

        if (name == null || name.length() == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.InvalidGroupName);
        }
        else
        {
            ReportHeading heading = report.getReportDefinition()
                .getAxis(axis).getHeading(level);
            ReportGroup group = new ReportGroup();
            group.setName(name);
            // make sure we are not adding a new group with a non-unique name
            List groups = heading.getReportGroups();
            if (groups != null && groups.contains(group)) 
            {
                scarabR.setAlertMessage(L10NKeySet.DuplicateGroupName);
            }
            else
            {
                heading.addReportGroup(group);
                
                params.remove("groupname_new");
                //params.setString("groupname_" + index, group.getName());
                scarabR.setConfirmMessage(L10NKeySet.GroupAdded);
            }

            /* intake way
            UIReportGroup group = new UIReportGroup();
            Group intakeGroup = intake.get("UIReportGroup", 
                                           group.getQueryKey(), false);
            if (intakeGroup != null) 
            {
                intakeGroup.setProperties(group);
                if (group.getDisplayValue() != null 
                     && group.getDisplayValue().length() > 0) 
                {
                    ReportHeading heading = report.getReportDefinition()
                        .getAxis(axis).getHeading(level);
                    ReportGroup rgroup = new ReportGroup();
                    rgroup.setName(group.getDisplayValue());
                    heading.addReportGroup(rgroup);
                }
            }
            */
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doDeletegroup(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }
        
                String[] groupIndices = params.getStrings("selectgroup");
        if (groupIndices == null || groupIndices.length == 0) 
        {
            scarabR.setAlertMessage(L10NKeySet.NoGroupSelected);
        }
        else
        {
            int axis = params.getInt("axis", 0); // 0=row; 1=column
            int level = params.getInt("heading", -1);
            List reportGroups = report.getReportDefinition()
                .getAxis(axis).getHeading(level).getReportGroups();

            for (int j = groupIndices.length-1; j>=0; j--) 
            {
                reportGroups.remove(Integer.parseInt(groupIndices[j]));
            }
            scarabR.setConfirmMessage(L10NKeySet.SelectedGroupDeleted);
                        
            /* intake way
            for (int i=groups.size()-1; i>=0; i--) 
            {
                ReportGroup rgroup = (ReportGroup)groups.get(i);
                UIReportGroup uirg = new UIReportGroup(rgroup.getName());
                Group intakeGroup = intake.get("UIReportGroup", 
                                               uirg.getQueryKey(), false);
                if (intakeGroup != null) 
                {
                    intakeGroup.setProperties(uirg);
                    if (uirg.isSelected())
                    {
                        groups.remove(i);
                    }
                }
            }
            */
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doEditgroupname(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }
        
        Object[] keys =  params.getKeys();
        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        List reportGroups = report.getReportDefinition()
            .getAxis(axis).getHeading(level).getReportGroups();

        for (int i =0; i < keys.length; i++)
        {
            String key = keys[i].toString();
            if (key.startsWith("groupname_") && key.indexOf("new") == -1)
            {
                int index = Integer.parseInt(key.substring(key.indexOf("_")+1,
                                             key.length()));
                ReportGroup group = (ReportGroup)reportGroups.get(index);
                String name = params.getString(key, "").trim();
                if (name.length() == 0)
                {
                    scarabR.setAlertMessage(L10NKeySet.InvalidGroupName);
                }
                else
                {
                    group.setName(name);
                }
            }
        }
        scarabR.setConfirmMessage(L10NKeySet.GroupsChanged);
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSavegroups(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        List reportGroups = heading.getReportGroups();
        // the form contains data to restore the groups and it is 
        // easier to start from scratch but grab a copy of the option/users
        // before resetting them to null.
        List groupedAttributes = heading.retrieveGroupedAttributes();
        for (Iterator i = reportGroups.iterator(); i.hasNext();) 
        {
            ReportGroup group = (ReportGroup)i.next();
            group.reset();
        }

        boolean success = true;
        if (heading.calculateType() == 0) 
        {
            for (Iterator j = groupedAttributes.iterator(); j.hasNext();) 
            {
                ReportOptionAttribute reportOption = 
                    (ReportOptionAttribute)j.next();
                String name = params.getString("option_" + 
                                               reportOption.getOptionId());
                if (name == null || name.trim().length() == 0) 
                {
                    scarabR.setAlertMessage(L10NKeySet.InvalidGroupName);
                    success = false;
                    break;
                }
                else 
                {
                    for (Iterator i = reportGroups.iterator(); i.hasNext();) 
                    {
                        ReportGroup group = (ReportGroup)i.next();
                        if (name.equals(group.getName())) 
                        {
                            group.addReportOptionAttribute(reportOption);
                        }
                    }
                }                
            }
        }
        else 
        {
            for (Iterator j = groupedAttributes.iterator(); j.hasNext();) 
            {
                ReportUserAttribute reportUser = 
                    (ReportUserAttribute)j.next();
                String name = params.getString(new StringBuffer(20)
                    .append("att_").append(reportUser.getAttributeId())
                    .append("user_").append(reportUser.getUserId()).toString());
                if (name == null || name.trim().length() == 0) 
                {
                    scarabR.setAlertMessage(L10NKeySet.InvalidGroupName);
                    success = false;
                    break;
                }
                else 
                {
                    for (Iterator i = reportGroups.iterator(); i.hasNext();) 
                    {
                        ReportGroup group = (ReportGroup)i.next();
                        if (name.equals(group.getName())) 
                        {
                            group.addReportUserAttribute(reportUser);
                        }
                    }
                }                
            }
        }

        if (success) 
        {
            setTarget(data, "reports,AxisConfiguration.vm");
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAdddate(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }


        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);

        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        // if level was -1, we have created a new level.  So mark the new
        // level as the current one.
        params.setString("heading", "0");
        
        List dates = heading.getReportDates();
        int index = 1;
        if (dates == null)
        {
            // make sure the heading does not contain old option or user data
            heading.reset();
        }
        else 
        {
            index = dates.size() + 1;
        }
        Calendar cal = scarabR.getCalendar();
        cal.set(Calendar.YEAR, params.getInt("y_" + index));
        cal.set(Calendar.MONTH, params.getInt("m_" + index) - 1);
        cal.set(Calendar.DAY_OF_MONTH, params.getInt("d_" + index));
        cal.set(Calendar.HOUR_OF_DAY, params.getInt("h_" + index));
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        ReportDate rdate = new ReportDate();
        rdate.setTime(cal.getTime().getTime());
        heading.addReportDate(rdate);
        scarabR.setConfirmMessage(L10NKeySet.DateAdded);
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAdddaterange(RunData data, TemplateContext context)
    throws Exception
    {
    	setup(data,context);
    	if (!report.isEditable(user)) 
    	{
    		setNoPermissionMessage();
    		setTarget(data, "reports,ReportList.vm");
    		return;
    	}


    	int axis = params.getInt("axis", 0); // 0=row; 1=column
    	int level = params.getInt("heading", -1);

    	ReportHeading heading = report.getReportDefinition()
        	.getAxis(axis).getHeading(level);
    	// if level was -1, we have created a new level.  So mark the new
    	// level as the current one.
    	params.setString("heading", "0");
    
    	List dates = heading.getReportDateRanges();
    	int index = 1;
    	if (dates == null)
    	{
    		// make sure the heading does not contain old option or user data
    		heading.reset();
    	}
    	else 
    	{
    		index = dates.size() + 1;
    	}

    	ReportDateRange rdaterange = new ReportDateRange();
    	
    	String stateChangeFromDate = ScarabUtil.findValue(data, "stateChangeFromDate");
    	String stateChangeToDate = ScarabUtil.findValue(data, "stateChangeToDate");
    	
    	boolean datesValid = true;
    	
    	if(stateChangeFromDate != null)
        {
    		
    		if(ScarabUtil.validateDateFormat(stateChangeFromDate, user.getLocale()))
                {
    		
    			rdaterange.setMinDateString(stateChangeFromDate);
    		
    		}
    		else
                {
    			
    			datesValid = false;
    			
    		}
    		
    	}
    	
    	if(stateChangeToDate != null)
        {
    		
    		if(ScarabUtil.validateDateFormat(stateChangeToDate, user.getLocale()))
                {
    		
    			rdaterange.setMaxDateString(stateChangeToDate);
    		
    		}
    		else
                {
    			
    			datesValid = false;
    			
    		}
    		
    	}
    	
    	if(stateChangeFromDate == null && stateChangeToDate == null)
        {
    		
    		datesValid = false;
    		
    	}
    	
    	if(datesValid)
        {
    		
    		heading.addReportDateRange(rdaterange);
        	
        	scarabR.setConfirmMessage(L10NKeySet.DateAdded);
    		
    	}
    	else{
    		
    		L10NMessage msg = new L10NMessage(L10NKeySet.DateFormatPrompt,L10NKeySet.ShortDateDisplay);
            scarabR.setAlertMessage(msg);
    		
    	}
    	   	
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doDeletedate(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }
        
        String[] dateIndices = params.getStrings("selectdate");
        if (dateIndices == null || dateIndices.length == 0) 
        {
            scarabR.setAlertMessage(L10NKeySet.NoDateSelected);
        }
        else
        {
            int axis = params.getInt("axis", 0); // 0=row; 1=column
            int level = params.getInt("heading", -1);
            List reportDates = report.getReportDefinition()
                .getAxis(axis).getHeading(level).getReportDates();

            for (int j = dateIndices.length-1; j>=0; j--) 
            {
                reportDates.remove(Integer.parseInt(dateIndices[j])-1);
            }
            scarabR.setConfirmMessage(L10NKeySet.SelectedDateDeleted);
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doDeletedaterange(RunData data, TemplateContext context)
    throws Exception
    {
    	setup(data,context);
    
    	if (!report.isEditable(user)) 
    	{
    		setNoPermissionMessage();
    		setTarget(data, "reports,ReportList.vm");
    		return;
    	}
    
    	String[] dateIndices = params.getStrings("selectdaterange");
    	if (dateIndices == null || dateIndices.length == 0) 
    	{
    		scarabR.setAlertMessage(L10NKeySet.NoDateSelected);
    	}
    	else
    	{
    		int axis = params.getInt("axis", 0); // 0=row; 1=column
    		int level = params.getInt("heading", -1);
    		List reportDateRanges = report.getReportDefinition()
            	.getAxis(axis).getHeading(level).getReportDateRanges();

        for (int j = dateIndices.length-1; j>=0; j--) 
        {
        	reportDateRanges.remove(Integer.parseInt(dateIndices[j])-1);
        }
        
        scarabR.setConfirmMessage(L10NKeySet.SelectedDateDeleted);
        
    }
}
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doRedirecttocrossmodulelist(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data,context);
        // x-module/issuetype works off of user's list, so make the report
        // list the current user's list.
        user.setCurrentMITList(
            report.getMITList());
        setTarget(data, "reports,XModuleList.vm");
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doConfinedataset(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        
        if ("fixed".equals(params.getString("def_date"))) 
        {
            Calendar cal = scarabR.getCalendar();
            cal.set(Calendar.YEAR, params.getInt("def_yr"));
            cal.set(Calendar.MONTH, params.getInt("def_month") - 1);
            cal.set(Calendar.DAY_OF_MONTH, params.getInt("def_day"));
            cal.set(Calendar.HOUR_OF_DAY, params.getInt("def_hr"));
            cal.set(Calendar.MINUTE, 0);
            cal.set(Calendar.SECOND, 0);
            report.setDefaultDate(cal.getTime());
        }
        else 
        {
            report.setDefaultDate(null);
        }
        scarabR.setConfirmMessage(L10NKeySet.ChangesSaved);
        setTarget(data, "reports,ConfineDataset.vm");
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSwaprowcol(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

              

        ReportDefinition reportDefn = report.getReportDefinition();
        List axes = reportDefn.getReportAxisList();
        if (axes != null && !axes.isEmpty()) 
        {
            if (axes.size() == 1) 
            {
                reportDefn.addReportAxis(new ReportAxis());
            }
            ReportAxis row = (ReportAxis)axes.remove(0);
            // add back as column
            reportDefn.addReportAxis(row);            
        }
        
        // FIXME: do we need a confirmation message? -jon
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doVerifyreport(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data,context);
        if (report.removeStaleDefinitions()) 
        {
            scarabR.setInfoMessage(l10n.get("ReportDefinitionModified"));
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doGeneratereport(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data,context);

        if (report.removeStaleDefinitions()) 
        {
            scarabR.setInfoMessage(l10n.get("ReportDefinitionModified"));
        }
        else if (report.getReportDefinition().reportQueryIsExpensive() ) 
        {
            scarabR.setAlertMessage(l10n.format("ReportIsTooExpensive", String.valueOf( 
                             report.getReportDefinition().maximumHeadings())));
        }
        else 
        {
        // Determine the report display format, looking first at the
        // request parameters.
        String format = ScarabUtil.findValue(data, ExportFormat.KEY_NAME);
        if (StringUtils.isEmpty(format))
        {
            // Next, examine the request for the Intake parameter
            // (which we'll allow to override a persisted pref).
            Group intakeReport = getIntakeReportGroup(getIntakeTool(context),
                                                      report);
            // Exports from the "Report output" screen have a null
            // Intake Group.
            if (intakeReport != null)
            {
                format = (String) intakeReport.get("Format").getValue();
            }

            if (format == null)
            {
                // Lastly, look at the persisted report format.
                format = report.getFormat();
            }
        }

        if (ExportFormat.EXCEL_FORMAT.equalsIgnoreCase(format)
            || ExportFormat.TSV_FORMAT.equalsIgnoreCase(format))
        {
            // The ReportExport screen has no corresponding template.
            data.getParameters().setString(ExportFormat.KEY_NAME, format);
            setTarget(data, "ReportExport.vm");
        }
        else
        {
            setTarget(data, "reports,Report_1.vm");
        }
            
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doCreatenew(RunData data, TemplateContext context)
        throws Exception
    {
        String key = data.getParameters()
            .getString(ScarabConstants.CURRENT_REPORT);
        data.getParameters().remove(ScarabConstants.CURRENT_REPORT);
        ScarabUser user = (ScarabUser)data.getUser();
        if (key != null && key.length() > 0) 
        {
            user.setCurrentReport(key, null);
        }
        if (user.getCurrentMITList() == null) 
        {
            //context.add("report", Boolean.TRUE);  
            setTarget(data, "reports,XModuleList.vm");
        }
        else 
        {
            setTarget(data, "reports,Info.vm");
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSavereport(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);        
        
        if (!report.isSavable((ScarabUser)data.getUser())) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");                        
        }
        else if (intake.isAllValid()) 
        {
            // make sure report has a name
            if (report.getName() == null || report.getName().trim().length() == 0) 
            {
                Group intakeReport = getIntakeReportGroup(intake, report);
                if (intakeReport != null) 
                {   
                    intakeReport.setValidProperties(report);
                }
            }

            if (report.getName() == null || report.getName().trim().length() == 0) 
            {
                scarabR.setAlertMessage(L10NKeySet.SavedReportsMustHaveName);
                setTarget(data, "reports,Info.vm");
            }
            else 
            {
                //don't save extra whitespace as part of name.
                String name = report.getName().trim();
                report.setName(name);
                // make sure name is unique, mysql text queries are 
                // case-insensitive, otherwise we may need to do this
                // differently to avoid similar but not exact matches.
                org.tigris.scarab.om.Report savedReport = ReportPeer
                    .retrieveByName(name);
                if (savedReport == null 
                    || savedReport.getQueryKey().equals(report.getQueryKey()))
                {
                    report.save();
                    scarabR.setConfirmMessage(L10NKeySet.ReportSaved);
                }
                else 
                {
                    scarabR.setAlertMessage(L10NKeySet.ReportNameNotUnique);
                    setTarget(data, "reports,Info.vm");
                }
            }
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.ErrorPreventedSavingReport);
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doDeletestoredreport(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        ScarabUser user = (ScarabUser)data.getUser();
        String[] reportIds = data.getParameters().getStrings("report_id");
        if (reportIds == null || reportIds.length == 0) 
        {
            scarabR.setAlertMessage(l10n.get("MustSelectReport"));
        }
        else 
        {
            for (int i=0;i<reportIds.length; i++)
            {
                String reportId = reportIds[i];
                if (reportId != null && reportId.length() > 0)
                {
                    Report torqueReport = ReportManager
                        .getInstance(new NumberKey(reportId), false);
                    if (new ReportBridge(torqueReport).isDeletable(user)) 
                    {
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }                   
                    else 
                    {
                        setNoPermissionMessage();
                    }
                }
            }
        }        
    }
              
// in java/org/tigris/scarab/actions/ConfigureReport.java
private Group getIntakeReportGroup(Intake intake, ReportBridge report)
        throws Exception
    {
        Group intakeReport = intake.get("Report", report.getQueryKey(), false);
        if (intakeReport == null) 
        {   
            intakeReport = intake.get("Report", "", false);
        }
        return intakeReport;
    }
              
// in java/org/tigris/scarab/actions/Register.java
public void doRegister(RunData data, TemplateContext context) 
        throws Exception
    {
        String template     = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        if(!intake.isAllValid())
            return;
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);

        Group register = intake.get("Register", IntakeTool.DEFAULT_KEY, false);

        String password = register.get("Password").toString();
        String passwordConfirm = register.get("PasswordConfirm").toString();

        if (!password.equals(passwordConfirm))
        {
            setTarget(data, template);
            scarabR.setAlertMessage(L10NKeySet.PasswordsDoNotMatch);
            return;
        }

        ScarabUser su = ScarabUserManager.getInstance();
        register.setProperties(su);
        
        if(!su.hasValidEmailAddress())
        {
            setTarget(data,template);
            scarabR.setAlertMessage(L10NKeySet.EnterValidEmailAddress);
            return;
        }
        
        ScarabUser existingUser=ScarabUserManager.getInstance(su.getUserName());
        if (existingUser!=null)
        {
            setTarget(data, template);
            scarabR.setAlertMessage(L10NKeySet.UsernameExistsAlready);
            return;
        }

        data.getUser().setTemp(ScarabConstants.SESSION_REGISTER, su);
        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/Register.java
public void doConfirmregistration(RunData data, TemplateContext context)
        throws Exception
    {
        String nextTemplate = getNextTemplate(data);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        ScarabUser su = (ScarabUser) data.getUser()
            .getTemp(ScarabConstants.SESSION_REGISTER);

        if (su == null)
        {
            setTarget(data, "Register.vm");
            return;
        }
        
        try
        {
            su.createNewUser();
        }
        catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
        data.getUser().setTemp(ScarabConstants.SESSION_REGISTER, null);
       scarabR.setUser(su);
        sendConfirmationEmail(su, context);

        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/Register.java
public void doBack(RunData data, TemplateContext context) 
        throws Exception
    {
        setTarget(data, data.getParameters().getString(
                ScarabConstants.CANCEL_TEMPLATE, "Register.vm"));
    }
              
// in java/org/tigris/scarab/actions/Register.java
public void doPerform(RunData data, TemplateContext context) 
        throws Exception
    {
        doConfirmregistration(data, context);
    }
              
// in java/org/tigris/scarab/actions/Register.java
public void doConfirm(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        if(!intake.isAllValid())
            return;
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);

        Group register = intake.get("Register", IntakeTool.DEFAULT_KEY, false);


        String username = register.get("UserName").toString();
        String confirm = register.get("Confirm").toString();

        ScarabUser u = ScarabUserManager.getInstance(username);

        if (u.isConfirmed())
        {
            scarabR.setAlertMessage(L10NKeySet.AccountConfirmedSuccess);
            setTarget(data, nextTemplate);
        }
        else
        {
            if (u.confirm(confirm))
            {
                u.save();
                data.getUser().setTemp(ScarabConstants.SESSION_REGISTER, null);

                scarabR.setConfirmMessage(L10NKeySet.AccountConfirmedSuccess);
                setTarget(data, nextTemplate);
            }
            else
            {
                scarabR.setAlertMessage(L10NKeySet.InvalidConfirmationCode);
                setTarget(data, template);
            }
        }
    }
              
// in java/org/tigris/scarab/actions/Register.java
public void doResendconfirmationcode(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
 
        IntakeTool intake = getIntakeTool(context);
        Group register = intake.get("Register", IntakeTool.DEFAULT_KEY, false);
   
        String username = register.get("UserName").toString();
        ScarabUser user = ScarabUserManager.getInstance(username);

        if(user==null)
        {
            String template = getCurrentTemplate(data, null);
            scarabR.setAlertMessage(L10NKeySet.InvalidUsername);
            setTarget(data, template);
            return;
        }
    
        if(user.isConfirmed())
        {
            String template = getCurrentTemplate(data, null);
            scarabR.setAlertMessage(L10NKeySet.AccountConfirmedSuccess);
            setTarget(data, template);
            return;
        }
       scarabR.setUser(user);
        sendConfirmationEmail(user, context);
        scarabR.setConfirmMessage(L10NKeySet.ConfirmationCodeSent);

        setTarget(data, "Confirm.vm");
    }
              
// in java/org/tigris/scarab/actions/Register.java
private void sendConfirmationEmail(ScarabUser su, TemplateContext context)
        throws Exception
    {
        Email te = new Email();

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Locale locale = l10n.getPrimaryLocale();
        String charset = Email.getCharset(locale);
        te.setCharset(charset);

        te.setContext(new ContextAdapter(context));
        te.addTo(su.getEmail(), su.getFirstName() + " " + su.getLastName());
        te.setFrom(
            Turbine.getConfiguration()
                .getString("scarab.email.register.fromAddress",
                           "register@localhost"),
            Turbine.getConfiguration()
                .getString("scarab.email.register.fromName",
                           "Scarab System"));
        te.setSubject(L10NKeySet.ConfirmationSubject.getMessage(l10n));
        te.setTemplate(
            Turbine.getConfiguration()
                .getString("scarab.email.register.template",
                           "email/Confirmation.vm"));
        te.send();        
    }
              
// in java/org/tigris/scarab/actions/TemplateList.java
public void doCreatenew(RunData data, TemplateContext context)
         throws Exception
    {        
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssueTemplate();
        if (issue == null)
        {
            scarabR.setAlertMessage(L10NKeySet.IssueTypeNotAvailable);
            return;
        }

        LinkedMap avMap = issue.getModuleAttributeValuesMap();
        AttributeValue aval = null;
        Group group = null;
        
        IssueTemplateInfo info = scarabR.getIssueTemplateInfo();
        Group infoGroup = intake.get("IssueTemplateInfo", info.getQueryKey());
        Group issueGroup = intake.get("Issue", issue.getQueryKey());
        ActivitySet activitySet = null;

        if (intake.isAllValid()) 
        {
            issueGroup.setProperties(issue);
            infoGroup.setProperties(info);
            if (checkForDupes(info, infoGroup.get("Name").toString(), 
                              user, issue))
            {
                scarabR.setAlertMessage(L10NKeySet.DuplicateTemplateName);
            }
            else
            {
                boolean atLeastOne = false;
                MapIterator iter = avMap.mapIterator();
                if (iter.hasNext()) 
                {
                    // Save activitySet record
                    activitySet = ActivitySetManager
                        .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
                    activitySet.save();
                    while (iter.hasNext()) 
                    {
                        aval = (AttributeValue)avMap.get(iter.next());
                        group = intake.get("AttributeValue", aval.getQueryKey(),false);
                        String value = null;
                        if (group != null)
                        {
                            if (aval instanceof OptionAttribute) 
                            {
                                value = group.get("OptionId").toString();
                            }
                            else 
                            {
                                value = group.get("Value").toString();
                            }
                            if (StringUtils.isNotEmpty(value))
                            {
                                atLeastOne = true;
                                aval.startActivitySet(activitySet);
                                group.setProperties(aval);
                            }
                        }
                    }
                }
                if (atLeastOne)
                {
                    issue.setCreatedTransId(activitySet.getActivitySetId());
                    issue.save();
                    info.setIssueId(issue.getIssueId());

                    // Save template info
                    info.saveAndSendEmail(user, 
                        scarabR.getCurrentModule(),
                        context);

                    // For a module-scoped template which is now
                    // pending approval, the user may not have
                    // permission to edit the new issue template.
                    if (info.canEdit(user))
                    {
                        data.getParameters().add
                            ("templateId", issue.getIssueId().toString());
                        scarabR.setConfirmMessage(L10NKeySet.NewTemplateCreated);
                    }
                    else
                    {
                        // Display the list of issue templates.
                        scarabR.setInfoMessage(
                            l10n.format("NotifyPendingApproval",
                            l10n.get("Template").toLowerCase()));
                        setTarget(data, "TemplateList.vm");
                        doPerform(data, context);
                    }
                }
                else
                {
                    scarabR.setAlertMessage(
                                L10NKeySet.AtLeastOneAttributeForTemplate);
                }
            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
              
// in java/org/tigris/scarab/actions/TemplateList.java
public void doEditvalues(RunData data, TemplateContext context)
         throws Exception
    {        
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssueTemplate();

        LinkedMap avMap = issue.getModuleAttributeValuesMap();
        AttributeValue aval = null;
        Group group = null;
        Group issueGroup = intake.get("Issue", issue.getQueryKey());
        issueGroup.setProperties(issue);

        if (intake.isAllValid()) 
        {
            AttributeValue aval2 = null;
            HashMap newAttVals = new HashMap();
            boolean modifiedAttribute = false;

            Iterator iter = avMap.mapIterator();
            while (iter.hasNext()) 
            {
                aval = (AttributeValue)avMap.get(iter.next());
                aval2 = AttributeValue.getNewInstance(aval.getAttributeId(),
                                                      aval.getIssue());
                aval2.setProperties(aval);
                group = intake.get("AttributeValue", aval.getQueryKey(),false);
                if (group != null)
                {
                    String newValue = "";
                    String oldValue = "";
                    if (aval instanceof OptionAttribute) 
                    {
                        newValue = group.get("OptionId").toString();
                        oldValue = aval.getOptionIdAsString();
                    
                        if (!newValue.equals(""))
                        {
                            AttributeOption newAttributeOption =
                              AttributeOptionManager
                              .getInstance(new Integer(newValue));
                            newValue = newAttributeOption.getName();
                        }
                        if (!oldValue.equals(""))
                        {
                            Integer oldOptionId = aval.getOptionId();
                            AttributeOption oldAttributeOption =
                              AttributeOptionManager
                              .getInstance(oldOptionId);
                            oldValue = oldAttributeOption.getName();
                        }
                        
                    }
                    else 
                    {
                        newValue = group.get("Value").toString();
                        oldValue = aval.getValue();
                    }
                    // A value has been entered for the attribute.
                    // The old value is different from the new, or is unset:
                    // Set new value.
                    if (newValue.trim().length() > 0 && (oldValue == null ||
                          !newValue.trim().equals(oldValue.trim())))
                    {
                        group.setProperties(aval2);
                        newAttVals.put(aval.getAttributeId(), aval2);
                        modifiedAttribute = true;
                    }
                    // The attribute is being undefined.
                    else if (oldValue != null && newValue.trim().length() == 0 &&
                             oldValue.trim().length() != 0)
                    {
                        aval2.setValue(null);
                        newAttVals.put(aval.getAttributeId(), aval2);
                        modifiedAttribute = true;
                    }
                }                
            }
            //save data only if there is a change
            if (modifiedAttribute)
            {
                issue.setAttributeValues(null, newAttVals, null, user);
                intake.removeAll();
            }
            scarabR.setConfirmMessage(L10NKeySet.TemplateModified);
        } 
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
              
// in java/org/tigris/scarab/actions/TemplateList.java
public boolean doEdittemplateinfo(RunData data, TemplateContext context)
         throws Exception
    {        
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssueTemplate();
        boolean success = true;

        IssueTemplateInfo info = scarabR.getIssueTemplateInfo();
        Group infoGroup = intake.get("IssueTemplateInfo", info.getQueryKey());

        if (intake.isAllValid()) 
        {
            infoGroup.setProperties(info);
            info.setIssueId(issue.getIssueId());
            if (checkForDupes(info, infoGroup.get("Name").toString(),
                              user, issue))
            {
                success = false;
                scarabR.setAlertMessage(L10NKeySet.DuplicateTemplateName);
            }
            else
            {
                // Save template info
                info.saveAndSendEmail(user, scarabR.getCurrentModule(), context);
                data.getParameters().add("templateId", issue.getIssueId().toString());
                if (info.canEdit(user))
                {
                    scarabR.setConfirmMessage(L10NKeySet.TemplateModified);
                }
                else
                {
                    scarabR.setInfoMessage(
                                    l10n.format("NotifyPendingApproval",
                                    l10n.get("Template").toLowerCase()));
                    setTarget(data, data.getParameters().getString(
                                    ScarabConstants.CANCEL_TEMPLATE));
                }
            }
        }
        else
        {
            success = false;
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/TemplateList.java
public void doDeletetemplates(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Object[] keys = data.getParameters().getKeys();
        String key;
        String templateId;
        ScarabUser user = (ScarabUser)data.getUser();
        boolean atLeastOne = false;
        boolean success = true;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
                atLeastOne = true;
                templateId = key.substring(7);
                try
                {
                    Issue issue = IssueManager
                       .getInstance(new NumberKey(templateId), false);
                    if (issue == null)
                    {
                        throw new Exception(
                            l10n.get("CouldNotLocateTemplateToDelete")); //EXCEPTION
                    }
                    issue.deleteItem(user);
                }
                catch (ScarabException e)
                {
                    success = false;
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
                catch (Exception e)
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.getMessage(e));
                }
            }
        } 
        if (!atLeastOne)
        {
            scarabR.setAlertMessage(L10NKeySet.NoTemplateSelected);
        }
        else if (success)
        {
            scarabR.setConfirmMessage(L10NKeySet.TemplateDeleted);
        } 
    }
              
// in java/org/tigris/scarab/actions/TemplateList.java
public void doUsetemplate(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        intake.removeAll();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String templateId = data.getParameters().getString("templateId");
        if (templateId != null && templateId.length() > 0) 
        {
            IssueType templateType = IssueManager.getInstance(
                new Long(templateId)).getIssueType();
            setTarget(data, scarabR.getNextEntryTemplate(
                templateType.getIssueTypeForTemplateType()));
            ReportIssue.cleanOutStaleIssue(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/TemplateList.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        doEditvalues(data, context);
        doEdittemplateinfo(data, context);
    }
              
// in java/org/tigris/scarab/actions/TemplateList.java
private boolean checkForDupes(IssueTemplateInfo template, 
                                  String newName, ScarabUser user, 
                                  Issue issueTemplate)
        throws Exception
    {
        boolean areThereDupes = false;
        Module module = issueTemplate.getModule();
        List prevTemplates = IssueTemplateInfoPeer.getUserTemplates(user, 
            module, issueTemplate.getIssueType().getIssueTypeForTemplateType());
        if (template.getScopeId().equals(Scope.MODULE__PK))
        {
            prevTemplates.addAll(IssueTemplateInfoPeer.getModuleTemplates(module));
        }
        if (prevTemplates != null && !prevTemplates.isEmpty())
        {
            Long pk = template.getIssueId();
            for (Iterator i = prevTemplates.iterator(); 
                 i.hasNext() && !areThereDupes;)
            {
                IssueTemplateInfo  t = (IssueTemplateInfo)i.next();
                areThereDupes = ((pk == null || !pk.equals(t.getIssueId())) &&
                    newName.trim().toLowerCase().equals(
                        t.getName().trim().toLowerCase()));
            }
        }
        return areThereDupes;
    }
              
// in java/org/tigris/scarab/actions/TemplateList.java
public void doDone(RunData data, TemplateContext context)  
        throws Exception
    {
        boolean success = doEdittemplateinfo(data, context);
        if (success)
        {
            doEditvalues(data, context);
            doCancel(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doGotoquerywithinternallist(RunData data,
                                            TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String listId = data.getParameters().getString("pd_list_id");
        if (listId == null || listId.length()==0)
        {
            scarabR.setAlertMessage(L10NKeySet.NoPredefinedXModuleListSelected);
        }
        else 
        {
            MITList list = null;
            ScarabUser user = (ScarabUser)data.getUser();
            if ("allmits".equals(listId)) 
            {
                list = MITListManager.getAllModulesAllIssueTypesList(user);
            }
            else 
            {
                IssueType issueType = IssueTypeManager
                    .getInstance(new Integer(listId.substring(13)));
                if (issueType.getDeleted()) 
                {

                    scarabR.setAlertMessage(L10NKeySet.GlobalIssueTypesDeleted);
                }
                else 
                {
                    list = MITListManager.getAllModulesSingleIssueTypeList(
                        issueType, user);                    
                }
            }
            user.setCurrentMITList(list);
            // reset selected users map
            scarabR.resetSelectedUsers();
            setTarget(data, data.getParameters()
                      .getString(ScarabConstants.NEXT_TEMPLATE));
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doFinished(RunData data, TemplateContext context)
        throws Exception
    {
        // add any last minute additions
        ScarabUser user = (ScarabUser)data.getUser();
        user.setCurrentMITList(new MITList());
        addSelectedRMITs(data, context);
        MITList currentList = user.getCurrentMITList();
        // reset selected users map
        getScarabRequestTool(context).resetSelectedUsers();

        if (currentList != null && !currentList.isEmpty()) 
        {
            setTarget(data, user.getQueryTarget());
        }
        else
        {
            ScarabRequestTool scarabR = getScarabRequestTool(context);
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            scarabR.setAlertMessage(L10NKeySet.ListWithAtLeastOneMITRequired);
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doFinishedreportlist(RunData data, TemplateContext context)
        throws Exception
    {
        doFinished(data, context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ReportBridge report = scarabR.getReport();
        if (!report.isEditable(user)) 
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        MITList mitList = user.getCurrentMITList();
        try 
        {
            report.setMITList(mitList);
            scarabR.setConfirmMessage(DEFAULT_MSG);

            if (!mitList.isSingleModule() && 
                Scope.MODULE__PK.equals(report.getScopeId())) 
            {
                report.setScopeId(Scope.PERSONAL__PK);
                scarabR.setInfoMessage(L10NKeySet.ScopeChangedToPersonal);
            }
            setTarget(data, "reports,Info.vm");
        }
        catch (IncompatibleMITListException e)
        {
            scarabR.setAlertMessage(L10NKeySet.IncompatibleMITListReport);
            setTarget(data, "reports,XModuleList.vm");
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doRemoveSavedlist(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String listId = data.getParameters().getString("list_id");
        if (listId == null || listId.length()==0)
        {
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            scarabR.setAlertMessage(L10NKeySet.NoSavedXModuleQuerySelected);
        }
        else 
        {
            // TODO: implement
        }        
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doRemoveitemsfromlist(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        String[] mitids = data.getParameters().getStrings("mitlistitem");
        if (mitids == null || mitids.length == 0) 
        {
            scarabR.setAlertMessage(L10NKeySet.NoItemsSelectedForRemoval);
        }
        else 
        {
            user.removeItemsFromCurrentMITList(mitids);
            scarabR.setConfirmMessage(
                l10n.format("NumberItemsRemoved", String.valueOf(mitids.length)));
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doGotosavelist(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        MITList list = user.getCurrentMITList();
        if (list == null) 
        {
            scarabR.setAlertMessage(L10NKeySet.ApplicationErrorListWasNull);
            Log.get().error("Current list was null in DefineXModuleList.doGotosavelist.");
        }
        else if (list.isAnonymous())
        {
            list.save();
            scarabR.setConfirmMessage(DEFAULT_MSG);
            String queryId = data.getParameters().getString("queryId");
            if (queryId != null && queryId.length() > 0) 
            {
                setTarget(data, "EditQuery.vm");
            }
        }
        else
        {
            list.setName(null);
            setTarget(data, "EditXModuleList.vm");
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doStartover(RunData data, TemplateContext context)
        throws Exception
    {
        ((ScarabUser)data.getUser()).setCurrentMITList(null);
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doSavelist(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
       
        if (intake.isAllValid()) 
        {
            ScarabUser user = (ScarabUser)data.getUser();
            MITList list = user.getCurrentMITList();
            Group group = 
                intake.get("MITList", list.getQueryKey(), false);
            group.setProperties(list);
            // check if the name already exists and inactivate the old list
            MITList oldList = MITListManager
                .getInstanceByName(list.getName(), user);
            if (oldList != null) 
            {
                // oldList should not be the same as the new, but checking
                // will not hurt
                if (!list.equals(oldList)) 
                {                                    
                    oldList.setActive(false);
                    oldList.save();
                }
            }
            // save the new list
            list.save();

            // Setting the current list to null
            // So that on IssueTypeList screen can select a saved list
            user.setCurrentMITList(null);
 
            scarabR.setConfirmMessage(DEFAULT_MSG);
            setTarget(data, data.getParameters()
                      .getString(ScarabConstants.LAST_TEMPLATE));
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doAddselectedrmits(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String[] rmitIds = data.getParameters().getStrings("rmitid");
        String listId = data.getParameters().getString("list_id");
        if ( (listId == null || listId.length() == 0)
             && (rmitIds == null || rmitIds.length == 0)
             && !data.getParameters().getBoolean("allit"))
        {
            scarabR.setAlertMessage(L10NKeySet.MustSelectAtLeastOneIssueType);
            return;
        }
        else 
        {
            addSelectedRMITs(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
private void addSelectedRMITs(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        String listId = data.getParameters().getString("list_id");
        if (listId != null && listId.length() != 0)
        {
            setAndGetCurrentList(listId, data, context);   
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (data.getParameters().getBoolean("allit")) 
        {
            Module module = user.getCurrentModule();
            List issueTypes = module.getIssueTypes(false);
            if (issueTypes == null || issueTypes.isEmpty())
            {
                scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                return;
            }
            MITList list = MITListManager.getSingleModuleAllIssueTypesList(
                module, user);
            addToUsersList(user, list.copy());
        }

        String[] rmitIds = data.getParameters().getStrings("rmitid");
        if (rmitIds != null && rmitIds.length != 0) 
        {
            List rmits = new ArrayList(rmitIds.length);
            boolean isIssueTypeAvailable = true;
            for (int i=0; i<rmitIds.length && isIssueTypeAvailable; i++)
            {
                try
                {
                    RModuleIssueType rmit = RModuleIssueTypeManager
                        .getInstance(rmitIds[i]);
                    if (rmit == null || rmit.getIssueType().getDeleted())
                    {
                        isIssueTypeAvailable = false;
                    }
                    else
                    {
                        rmits.add(rmit);
                    }
                }
                catch (Exception e)
                {
                    // would probably be a hack of the form
                    scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                    Log.get().debug("", e);
                    return;
                }
            }
            if (isIssueTypeAvailable)
            {
                user.addRMITsToCurrentMITList(rmits);
            }
            else
            {
                scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
            }
        }
        
        // Another oddity due to ScarabUserImpl not extending
        // AbstractScarabUser
        MITList mitlist = user.getCurrentMITList();
        if (mitlist != null) 
        {
            mitlist.setScarabUser(user);            
        }
    }
              
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doToggleothermodules(RunData data, TemplateContext context)
        throws Exception
    {
        String flag = data.getParameters()
            .getString("eventSubmit_doToggleothermodules");
        ((ScarabUser)data.getUser()).setShowOtherModulesInIssueTypeList(
            "show".equals(flag));
    }
              
// in java/org/tigris/scarab/actions/ViewIssue.java
public void doSetissueview(RunData data, TemplateContext context)
         throws Exception
    {
        // fetch property here so it can be changed at runtime
        final boolean singleScreenOnly = Turbine.getConfiguration()
            .getBoolean(ScarabConstants.SINGLE_SCREEN_ONLY, false);
        // the velocity template hides the link to actually get here,
        //  but just to be extra secure.
        
        String tabmode = data.getParameters().getString("tabmode");
        
        if(tabmode == null){
       	 
       	 	tabmode = (String)data.getUser().getTemp("tabmode");
       	 	
       	 	if(tabmode == null){
         	
       	 		if(singleScreenOnly){
             	
       	 			tabmode = "all";
             	
       	 		}
       	 		else{
             	
             		tabmode = "tabs";
             	
       	 		}
         	
       	 	}
       	 
        }
         
         String tab = null;
         
         if(tabmode.equals("all")){
        	 
        	 tab = ScarabConstants.ISSUE_VIEW_ALL;
        	 
         }
         else{
        	 
        	 tab = data.getParameters().getString("tab");
        	 
         }
         
         if(tab == null){
        	 
        	 tab = "1";
        	 
         }
         
         data.getUser().setTemp(ScarabConstants.TAB_KEY, tab); 
         data.getUser().setTemp("tabmode", tabmode); 
    }
              
// in java/org/tigris/scarab/actions/ModifyModule.java
public void doUpdate(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        if (intake.isAllValid())
        {
            Module me = null;
            try
            {
                me = scarabR.getModule();
            }
            catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }

            Group moduleGroup = intake.get
                ("Module",me.getQueryKey(), false);

            if (moduleGroup == null)
            {
                setTarget(data, template);
                scarabR.setAlertMessage(
                    L10NKeySet.CouldNotLocateModuleGroup);
                return;
            }
            else
            {
                ScarabUser user = (ScarabUser) data.getUser();

                // make sure that the user has Edit permission 
                // in the module.
                if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, me))
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                    intake.remove(moduleGroup);
                    setTarget(data, nextTemplate);
                    return;
                }

                Module origParent = me.getParent();
                String origCode = me.getCode();
                moduleGroup.setProperties(me);
                Module newParent = me.getParent();
                String newCode = me.getCode();

                if (newParent.getParent() == me && origParent!=me)
                {
                    scarabR.setAlertMessage(L10NKeySet.CircularParentChildRelationship);
                    intake.remove(moduleGroup);
                    setTarget(data, template);
                    return;
                }
                else if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, origParent) && 
                    origParent.getModuleId() != newParent.getModuleId())
                {
                    scarabR.setAlertMessage(L10NKeySet.NoPermissionInParentModule);
                    setTarget(data, template);
                    return;
                }
                
                // Cascade update the code to the (denormalized) issue prefix
                if (! newCode.equals(origCode))
                {
                    if (me instanceof ScarabModule)
                    {
                        ScarabModule sm = (ScarabModule)me;
                        List issues = sm.getIssues();
                        for (int i = 0; i < issues.size(); i++)
                        {
                            Issue issue = (Issue)issues.get(i);
                            if (! issue.getIdPrefix().equals(me.getCode()))
                            {
                                issue.setIdPrefix(me.getCode());
                                issue.save();
                            }
                        }
                        //Update the ID table to reflect the module code r
                        // FIXME: Using SQL because IDBroker doesn't have a Peer yet.
                        String idTable = IDBroker.TABLE_NAME.substring(0, 
                                IDBroker.TABLE_NAME.indexOf('.'));
                        String instanceId = GlobalParameterManager
                        .getString(ScarabConstants.INSTANCE_ID);
                        String sql = "update " + idTable 
                         + " SET TABLE_NAME='" + instanceId + "-" + newCode + "' WHERE TABLE_NAME='" +
                         instanceId + "-" + origCode + "'";
                        BasePeer.executeStatement(sql);                                                
                    }
                    else
                    {
                        throw new Exception ("Did not get a ScarabModule"); //EXCEPTION
                    }
                }
                
                me.save();

                updateModuleParameters(data, me);
                
                intake.remove(moduleGroup);
                setTarget(data, nextTemplate);
                scarabR.setConfirmMessage(L10NKeySet.ModuleUpdated);
            }
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyModule.java
public void doCreate(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        if (intake.isAllValid())
        {
            Group moduleGroup = intake.get
                ("Module",IntakeTool.DEFAULT_KEY, false);
            Module me = ModuleManager.getInstance();
            if (moduleGroup == null)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
            moduleGroup.setProperties(me);
            ScarabUser user = (ScarabUser)data.getUser();
            
            // make sure that the user has Edit permission 
            // in the parent module.
            if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, 
                me.getParent()))
            {
                scarabR.setAlertMessage(L10NKeySet.NoPermissionInParentModule);
            }
            else
            {
            	try{
	                me.setOwnerId(user.getUserId());
	                me.save();
	                
	                updateModuleParameters(data, me);
	
	                data.setACL(((ScarabUser)data.getUser()).getACL());
	                data.save();
	
	                scarabR.setConfirmMessage(L10NKeySet.NewModuleCreated);
	                intake.remove(moduleGroup);
            	}
                catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
            }
        }
        else
        {
            setTarget(data, template);
            return;
        }
        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/QueryList.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
       
        if (intake.isAllValid())
        {
            boolean valid = true;
            List queries = scarabR.getAllQueries();
            for (int i = 0; i < queries.size(); i++)
            {    
                Query query = (Query)queries.get(i);
                RQueryUser rqu = query.getRQueryUser(user);
                Group queryGroup = intake.get("RQueryUser",
                                              rqu.getQueryKey(), false);
                if (queryGroup != null)
                {
                    Field sub = queryGroup.get("Subscribed");
                    if (sub.toString().equals("true"))
                    {
                        Field freq = queryGroup.get("Frequency");
                        freq.setRequired(true);
                        if (!freq.isValid())
                        {
                            valid = false;
                            freq.setMessage("EnterSubscriptionFrequency");
                        }
                    }                
                    if (valid) 
                    {
                        queryGroup.setProperties(rqu);
                        rqu.save();
                    }
                }
            }
       }
       else
       {
           scarabR.setAlertMessage(ERROR_MESSAGE);
       }
       ScarabCache.clear();
    }
              
// in java/org/tigris/scarab/actions/QueryList.java
public void doDeletequeries(RunData data, TemplateContext context)
        throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key;
        String queryId;
        ScarabUser user = (ScarabUser)data.getUser();

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
               queryId = key.substring(7);
               Query query = QueryManager
                   .getInstance(new NumberKey(queryId), false);
               try
               {
                   query.delete(user);
                   query.save();
               }
               catch (Exception e)
               {
                   ScarabLocalizationTool l10n = getLocalizationTool(context);
                   getScarabRequestTool(context).setAlertMessage(NO_PERMISSION_MESSAGE);
               }

            }
        } 
    }
              
// in java/org/tigris/scarab/actions/QueryList.java
public void doCopyquery(RunData data, TemplateContext context)
        throws Exception
    {
        ParameterParser pp = data.getParameters();
        Object[] keys = pp.getKeys();
        String key;
        String queryId;
        Query query;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
               queryId = key.substring(7);
               query = QueryManager
                   .getInstance(new NumberKey(queryId), false);
               query.copyQuery((ScarabUser)data.getUser());
             }
         }
     }
              
// in java/org/tigris/scarab/actions/QueryList.java
public void doGotoadvancedquery(RunData data, TemplateContext context)
        throws Exception
    {
        // reset the MITList
        ScarabUser user = (ScarabUser)data.getUser();
        user.setCurrentMITList(null);
        // reset selected users map
        getScarabRequestTool(context).resetSelectedUsers();
        setTarget(data, user.getQueryTarget());
    }
              
// in java/org/tigris/scarab/actions/QueryList.java
public void doSetstartpage(RunData data, TemplateContext context) throws Exception
    {
        ParameterParser pp = data.getParameters();   
        String queryId = pp.get("startpage");
        
        List<Query> privateQueries = getScarabRequestTool(context).getUserAllQueries();
        Query newStartQuery = QueryManager.getInstance(new NumberKey(queryId), false);
        
        boolean addedAsStartQuery;
        
        addedAsStartQuery = setStartpage(privateQueries, newStartQuery);       
        if(addedAsStartQuery)
        {
            // We just have added a private query as startPage.
            // We will not deal with the public queries.
            // Consequently we can have more than one startQuery per module.
        }
        else
        {
            // Since we have not marked a personal query as start page we probably
            // are dealing with a public query, hence we must process the public query list
            // too.
            List<Query> globalQueries  = getScarabRequestTool(context).getGlobalQueries();
            setStartpage(globalQueries, newStartQuery);
        }
    }
              
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
    }
              
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doGonext(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getNextTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doGotoothertemplate(RunData data, 
                                     TemplateContext context)
        throws Exception
    {
        data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE,
                                       getCurrentTemplate(data));
        setTarget(data, getOtherTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doRefresh(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getCurrentTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doReset(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        intake.removeAll();
        setTarget(data, getCurrentTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doCancel(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getCancelTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        doSave(data, context);
        doCancel(data, context);
    }
              
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doRefreshresultsperpage(RunData data, TemplateContext context) 
        throws Exception
    {
        ParameterParser params = data.getParameters();
        int oldResultsPerPage = params.getInt("oldResultsPerPage");
        int newResultsPerPage = params.getInt("resultsPerPage");
        int oldPageNum = params.getInt("pageNum");
        
        //
        // We want to display whichever page contains the first issue
        // on the old page.
        //
        int firstItem = (oldPageNum - 1) * oldResultsPerPage + 1;
        int newPageNum = (firstItem / newResultsPerPage) + 1;
        params.remove("oldResultsPerPage");
        params.remove("pageNum");
        params.add("pageNum", newPageNum);
        setTarget(data, getCurrentTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
protected boolean isAuthorized(RunData data) throws Exception
    {
        boolean auth = false;
        String perm = getRequiredPermission(data);
        TemplateContext context = getTemplateContext(data);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module currentModule = scarabR.getCurrentModule();
        ScarabUser user = (ScarabUser)data.getUser();

        if (ScarabSecurity.NONE.equals(perm)) 
        {
            if (!user.hasLoggedIn()) 
            {
                scarabR.setInfoMessage(L10NKeySet.LoginToAccountWithPermissions);
                Default.setTargetLogin(data);
                scarabR.setCurrentModule(null);
            }
            else 
            {
                auth = true;
            }
        }
        else if (perm == null)
        {
            scarabR.setAlertMessage(L10NKeySet.ActionNotAssignedPermission);
        }
        else
        {
            if (currentModule == null)
            {
                scarabR.setInfoMessage(L10NKeySet.SelectModuleToWorkIn);
                Default.setTargetSelectModule(data);
            }
            else if (! user.hasLoggedIn() 
                || !user.hasPermission(perm, currentModule))
            {
                scarabR.setInfoMessage(L10NKeySet.LoginToAccountWithPermissions);

                Default.setTargetLogin(data);
                scarabR.setCurrentModule(null);
            }
            else 
            {
                auth = true;
            }
        }
        return auth;
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doGonext(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getNextTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doGotoothertemplate(RunData data, 
                                     TemplateContext context)
        throws Exception
    {
        data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE,
                                       getCurrentTemplate(data));
        setTarget(data, getOtherTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doRefresh(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getCurrentTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doRefreshresultsperpage(RunData data, TemplateContext context) 
        throws Exception
    {
        ParameterParser params = data.getParameters();
        int oldResultsPerPage = params.getInt("oldResultsPerPage");
        int newResultsPerPage = params.getInt("resultsPerPage");
        int oldPageNum = params.getInt("pageNum");
        
        //
        // We want to display whichever page contains the first issue
        // on the old page.
        //
        int firstItem = (oldPageNum - 1) * oldResultsPerPage + 1;
        int newPageNum = (firstItem / newResultsPerPage) + 1;
        params.remove("oldResultsPerPage");
        params.remove("pageNum");
        params.add("pageNum", newPageNum);
        setTarget(data, getCurrentTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doReset(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        intake.removeAll();
        setTarget(data, getCurrentTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doCancel(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getCancelTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        doSave(data, context);
        doCancel(data, context);
    }
              
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public boolean areThereDupeSequences(List list, IntakeTool intake,
               String groupName, String fieldName, int dedupeSeq)
        throws Exception
    {
        boolean dupeSequenceFound = false;
        int listSize = (list==null)?0:list.size();
        Field order1 = null;
        Field order2 = null;
        for (int i = 0; i < listSize && !dupeSequenceFound; i++)
        {
            Retrievable obj1 = (Retrievable)list.get(i);
            Group group1 = intake.get(groupName,obj1.getQueryKey(),false);
            order1 = group1.get(fieldName);

            if (dedupeSeq > 0 && order1.toString().equals(
                                          Integer.toString(dedupeSeq)))
            {
                dupeSequenceFound = true;
            }

            for (int j = i - 1; j >= 0 && !dupeSequenceFound; j--)
            {
                Retrievable obj2 = (Retrievable)list.get(j);
                Group group2 = intake.get(groupName,obj2.getQueryKey(),
                                             false);
                order2 = group2.get(fieldName);
                if (order1.toString().equals(order2.toString()))
                {
                    dupeSequenceFound = true;
                }
            }
        }
        return dupeSequenceFound;
    }
              
// in java/org/tigris/scarab/actions/base/BaseModifyIssue.java
protected boolean isCollision(RunData data, TemplateContext context)
        throws Exception
    {
        boolean isCollision = false;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        long modTimestamp = data.getParameters().getLong("mod_ts");

        String id = data.getParameters().getString("id");
        if (id == null) 
        {
            List issues = scarabR.getIssues();
            List conflictIssues = new ArrayList(issues.size());
            Iterator iter = issues.iterator();
            while (iter.hasNext()) 
            {
                Issue issue = (Issue)iter.next();
                long lastModTime = issue.getModifiedDate().getTime();
                boolean isSingleCollision = modTimestamp < lastModTime;
                if (isSingleCollision) 
                {
                    isCollision = true;
                    scarabR.setAlertMessage(
                        l10n.get("MultiIssueChangeCollision"));
                    ActivitySet lastActivitySet = issue.getLastActivitySet();
                    ArrayList objs = new ArrayList(2);
                    objs.add(issue);
                    objs.add(lastActivitySet);
                    conflictIssues.add(objs);
                }
            }
            context.put("lastActivities", conflictIssues);
        }
        else
        {
            Issue issue = IssueManager.getIssueById(id);
            List conflictIssues = new ArrayList(1);
            long lastModTime = issue.getModifiedDate().getTime();
            isCollision = modTimestamp < lastModTime;
            if (isCollision) 
            {
                scarabR.setAlertMessage(l10n.get("IssueChangeCollision"));
                ActivitySet lastActivitySet = issue.getLastActivitySet();
                ArrayList objs = new ArrayList(2);
                objs.add(issue);
                objs.add(lastActivitySet);
                conflictIssues.add(objs);
                context.put("lastActivities", conflictIssues);
            }
        }        
        return isCollision;
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doCheckforduplicates(data, context);
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
private boolean checkIssueTypeStatus(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getReportingIssue();
        Module module = issue.getModule();
        IssueType issueType = issue.getIssueType();
        boolean isValid = module != null && !module.getDeleted() &&
            issueType != null;
        if (isValid)
        {
            RModuleIssueType rmit = module.getRModuleIssueType(issueType);
            isValid = rmit != null && rmit.getActive();
        }

        if (!isValid)
        {
          scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
          data.setTarget( ((ScarabUser)data.getUser()).getHomePage());
          cleanup(data, context);
        }
        return isValid;
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doCheckforduplicates(RunData data, TemplateContext context)
        throws Exception
    {
        if (checkIssueTypeStatus(data, context))
        {
            checkForDuplicates(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void checkForDuplicates(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        try
        {
            Issue issue = scarabR.getReportingIssue();
            LinkedMap avMap = issue.getModuleAttributeValuesMap();

            // set the values entered so far and if that is successful look
            // for duplicates
            if (setAttributeValues(issue, intake, context, avMap))
            {
                // check for duplicates, if there are none skip the dedupe page
                searchAndSetTemplate(data, context, 0, MAX_RESULTS, issue,
                                     "entry,Wizard3.vm");
            }
        }
        catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }

        // we know we started at Wizard1 if we are here, Wizard3 needs
        // to know where the issue entry process starts because it may
        // branch back
        data.getParameters()
            .add(ScarabConstants.HISTORY_SCREEN, "entry,Wizard1.vm");
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
private boolean searchAndSetTemplate(RunData data,
                                         TemplateContext context,
                                         int threshold,
                                         int maxResults,
                                         Issue issue,
                                         String nextTemplate)
        throws Exception
    {
        // if all of the attributes are unset, then we don't need to run
        // this query...just break out of it early...
        List attributeValues = issue.getAttributeValues();
        boolean hasSetValues = false;
        for (Iterator itr = attributeValues.iterator();
             itr.hasNext() && !hasSetValues;) 
        {
            AttributeValue attVal = (AttributeValue) itr.next();
            hasSetValues = attVal.isSet();
        }
        if (!hasSetValues)
        {
            setTarget(data, nextTemplate);
            return true;
        }

        String template = null;
        boolean dupThresholdExceeded = false;
        IssueSearch duplicateSearch = IssueSearchFactory.INSTANCE.getInstance(issue, (ScarabUser)data.getUser());
        duplicateSearch.setLocalizationTool(getLocalizationTool(context));
        
        List possibleDuplicates = duplicateSearch.getQueryResults();
        dupThresholdExceeded = possibleDuplicates.size() > threshold;
        if (dupThresholdExceeded)
        {
            List possibleDuplicateIds = new ArrayList(maxResults);
            Iterator resultsIterator = possibleDuplicates.iterator();

            for (int i = 0; resultsIterator.hasNext() && i <= maxResults; i++) 
            {
                possibleDuplicateIds.add(((QueryResult)resultsIterator.next()).getUniqueId());
            }
            context.put("issueList", possibleDuplicateIds);
            template = "entry,Wizard2.vm";
        }
        else
        {
            template = nextTemplate;
        }
        
        setTarget(data, template);
        return dupThresholdExceeded;
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
private void setRequiredFlags(Issue issue, IntakeTool intake,
    		LinkedMap avMap, TemplateContext context)
        throws Exception
    {
        if (issue == null)
        {
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            throw new Exception(l10n.get("IssueNoLongerValid")); //EXCEPTION
        }
        Set selectedOptions = new HashSet();
        Map conditionallyRequiredFields = new HashMap(); 
        IssueType issueType = issue.getIssueType();
        List requiredAttributes = issueType
            .getRequiredAttributes(issue.getModule());
        for (MapIterator iter = avMap.mapIterator(); iter.hasNext();)
        {
            AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            
            Group group = 
                intake.get("AttributeValue", aval.getQueryKey(), false);
            if (group != null) 
            {            
                Field field = null;
                if (aval instanceof OptionAttribute) 
                {
                    field = group.get("OptionId");
                    // Will store the selected optionId, for later query.
                    Object fieldValue = field.getValue();
                    if (null != fieldValue)
                    {
                        selectedOptions.add(fieldValue);
                    }                    
                }
                else if (aval instanceof IntegerAttribute) 
                {
                    field = group.get("NumericValue");
                }
                else if (aval instanceof UserAttribute) 
                {
                    field = group.get("UserId");
                }
                else 
                {
                    field = group.get("Value");
                }

                /**
                 * If the field has any conditional constraint, will be added to the collection
                 * in the hash.
                 */ 
                List conditions = aval.getRModuleAttribute().getConditions(); 
                if (conditions.size() > 0)
                {
                    for (Iterator it = conditions.iterator(); it.hasNext(); )
                    {
                        Condition cond = (Condition)it.next();
                        Integer id = cond.getOptionId();
                        List fields = (List)conditionallyRequiredFields.get(id);
                        if (fields == null)
                        {
                            fields = new ArrayList();
                        }
                        fields.add(field);
                        conditionallyRequiredFields.put(id, fields);
                    }
                }                
                
                for (int j=requiredAttributes.size()-1; j>=0; j--) 
                {
                    if (aval.getAttribute().getPrimaryKey().equals(
                            ((Attribute)requiredAttributes.get(j)).getPrimaryKey())
                        && !aval.isSet())
                    {
                        field.setRequired(true);
                        break;
                    }                    
                }
            }
        }
        /**
         * Now that we have all the info, we will force the 'required' status of any field
         * whose requiredOptionId has been set in the issue.
         */
        for (Iterator requiredIds = conditionallyRequiredFields.keySet().iterator(); requiredIds.hasNext(); )
        {
            Integer attributeId= (Integer)requiredIds.next();
            if (selectedOptions.contains(attributeId))
            {
                List fields = (List)conditionallyRequiredFields.get(attributeId);
                for (Iterator iter = fields.iterator(); iter.hasNext(); )
                {
                    Field field = (Field)iter.next();
            	    if (field.getValue().toString().length() == 0)
            	    {
            	       field.setRequired(true);
            	       field.setMessage("ConditionallyRequiredAttribute");
            	    }
                }
            }
        }        
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
private boolean setAttributeValues(Issue issue, IntakeTool intake, 
                                       TemplateContext context,
                                       LinkedMap avMap)
        throws Exception
    {
        boolean success = false;
        // set any required flags on attribute values
        setRequiredFlags(issue, intake, avMap, context);
        if (intake.isAllValid()) 
        {
            for (MapIterator i = avMap.mapIterator();i.hasNext();) 
            {
                AttributeValue aval = (AttributeValue)avMap.get(i.next());
                Group group = 
                    intake.get("AttributeValue", aval.getQueryKey(), false);
                if (group != null) 
                {
                	
                    Field field = null;
                    if(aval instanceof OptionAttribute){
                    	field = group.get("OptionId");
                    }
                    else if(aval instanceof IntegerAttribute){
                    	field = group.get("NumericValue");
                    } 
                    else{
                    	field = group.get("Value");
                    }
                    	
                    String value = field.toString();

                    if (value != null && value.length() > 0)
                    {
                        group.setProperties(aval);
                    }
                }
            }
            success = true;
        }
        else
        {
            getScarabRequestTool(context).setAlertMessage(ERROR_MESSAGE);
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doEnterissue(RunData data, TemplateContext context)
        throws Exception
    {
        if (checkIssueTypeStatus(data, context))
        {
            enterIssue(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
private void enterIssue(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getReportingIssue();
        ScarabUser user = (ScarabUser)data.getUser();
        LinkedMap avMap = issue.getModuleAttributeValuesMap(); 

        // set the attribute values and if that was successful save the issue.
        if (setAttributeValues(issue, intake, context, avMap))
        {
            DateAttribute.convertDateAttributes(issue.getAttributeValues(), getLocalizationTool(context).get("ShortDatePattern"));
            if (issue.containsMinimumAttributeValues())
            {
                // we need to see that the default text was filled out 
                // if necessary.  We can
                // only do this after setting the attributes above.
                boolean saveIssue = true;
                Group reasonGroup = intake.get("Attachment", "_1", false);
                Field reasonField = reasonGroup.get("Data");
                if (issue.getDefaultTextAttributeValue() == null)
                {
                    reasonField.setRequired(true);
                    saveIssue = false;
                }

                // if the reason field is to long, then show an error.
                String reasonString = reasonField.toString();
                if (reasonString != null && reasonString.length() > 254)
                {
                    reasonField.setMessage("intake_ReasonMustBeLessThan256Characters");
                    saveIssue = false;
                }
                // If there is a default text attribute,or if a comment has 
                // Been provided, proceed.
                if (reasonField.isValid() || saveIssue)
                {
                    HashMap newValues = new HashMap();
                    List modAttrs = issue.getModule()
                        .getRModuleAttributes(issue.getIssueType(), true, "all");

                    boolean foundLocalFieldErrors = false;
                    
                    // this is used for the workflow stuff...FIXME: it should
                    // be refactored as soon as we possibly can. the reason is
                    // that all of this data can be retrieved by simply using
                    // issue.getModuleAttributeValuesMap() because the call
                    // to setAttributeValues() above already gets the group
                    // information into the module attribute values.
                    for (int i = 0; i<modAttrs.size(); i++)
                    {
                        Attribute attr = ((RModuleAttribute)modAttrs.get(i)).getAttribute();
                        String queryKey = "__" + attr.getAttributeId().toString();
                        Group group = intake.get("AttributeValue", queryKey, false);
                        String newValue = "";

                        if (group != null) 
                        {
                            Field field = null;
                            if (attr.isOptionAttribute())
                            {
                                field = group.get("OptionId");
                            }
                            else 
                            {
                                field    = group.get("Value");
                            }
                            newValue = field.toString();

                            if (newValue.length() != 0)
                            {
                                String pattern = attr.getFormat();
                                String hint    = attr.getHint();
                                boolean exactMatch = true;
                                if(pattern != null && pattern.length()>0)
                                {
                                    RegexProcessor processor = new RegexProcessor();
                                    exactMatch = processor.matches(newValue, pattern);
                                }
                                if(exactMatch)
                                {
                                    newValues.put(attr.getAttributeId(), newValue);
                                }
                                else
                                {                                                                      
                                    String[] parameters = new String[]{attr.getName(), newValue, pattern, hint};
                                    LocalizationKey key;
                                    if(newValue.equals(hint))
                                    {
                                        key = L10NKeySet.UnprocessedField;
                                    }
                                    else
                                    {
                                        key = L10NKeySet.InvalidFieldFormat;
                                    }
                                    L10NMessage l10nMessage = new L10NMessage(key, parameters);
                                    field.setMessage(l10nMessage.getMessage(l10n));
                                    foundLocalFieldErrors = true;
                                }
                            }
                        }
                    }
                    
                    
                    if (foundLocalFieldErrors) 
                    {
                        scarabR.setAlertMessage(ERROR_MESSAGE);
                        // were obviously in editing mode
                        data.getParameters().add("edit_attributes", "true");
                        // preserve fullcomments mode
                        data.getParameters().add("fullcomments", data.getParameters().get("fullcomments"));
                        return;
                    }
                    
                    
                    
                    // Save the Reason
                    ActivitySet activitySet = null;
                    Attachment reason = null;
                    try
                    {
                        // grab the comment data
                        reason = new Attachment();
                        reasonField.setProperty(reason);
                        activitySet = issue
                            .setInitialAttributeValues(activitySet, reason, newValues, user);
                    }
                    catch (Exception se)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        return;
                    }

                    // Save any unsaved attachments as part of this ActivitySet as well
                    activitySet = issue.doSaveFileAttachments(activitySet, user);

                    // set the template to the user selected value
                    int templateCode = data.getParameters()
                        .getInt("template_code", 2);
                
                    // if user preference for next template is unset,
                    // set it.
                    int userPref = user.getEnterIssueRedirect();
                    if (userPref == 0 || userPref != templateCode)
                    {
                        user.setEnterIssueRedirect(templateCode);
                    }
                    doRedirect(data, context, templateCode, issue);
                
                    NotificationManagerFactory.getInstance()
                            .addActivityNotification(
                                    ActivityType.ISSUE_CREATED,
                                    activitySet, issue, user);                        

                    String assignActiveUser = data.getParameters().get("add_user");
                    if(assignActiveUser != null && assignActiveUser.length() > 0)
                    {                      
                        // Lets cross-call the AssignIssue Turbine action!
                        AssignIssue assignAction = new AssignIssue();
                        assignAction.doAdd(data, context);
                        assignAction.doSave(data, context);
                    }
                  
                    String assignWatcherUser = data.getParameters().get("add_watcher");
                    if(assignWatcherUser != null && assignWatcherUser.length() > 0)
                    {
                        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                            issue.getModule()))
                        {
                            // We'll set the info required by AssignIssue.doAddmyself (the)
                            // same that in doEditassignees in this same class.
                            data.getParameters().add("id", issue.getUniqueId());
                            data.getParameters().add("issue_ids", issue.getUniqueId());
                            String watcher = data.getParameters().get("add_watcher");
                            data.getParameters().remove("add_user");
                            data.getParameters().add("add_user", watcher);
                
                            scarabR.resetAssociatedUsers();
                            
                            // Lets cross-call the AssignIssue Turbine action!
                            AssignIssue assignAction = new AssignIssue();
                            assignAction.doAdd(data, context);
                            assignAction.doSave(data, context);
                        }
                        else
                        {
                            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                        }
                    }
                  
                  
                    cleanup(data, context);
                    data.getParameters().add("id", issue.getUniqueId().toString());
                    L10NMessage l10nMessage = 
                        new L10NMessage(L10NKeySet.IssueAddedToModule,
                            issue.getUniqueId(), 
                            getScarabRequestTool(context).getCurrentModule().getRealName());
                    scarabR.setConfirmMessage(l10nMessage);
                }
                else
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                }
            }
            else 
            {
                // this would be an application or hacking error
            }
        }
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doAddfile(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getReportingIssue();
        Attachment attachment = AttachmentManager.getInstance();
        Group group = intake.get("Attachment", 
                                 attachment.getQueryKey(), false);

        ModifyIssue
            .addFileAttachment(issue, group, attachment, scarabR, data, intake);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (scarabR.getAlertMessage() == null)
        {
            scarabR.setConfirmMessage(L10NKeySet.FileAdded);
        }

        LinkedMap avMap = issue.getModuleAttributeValuesMap(); 
        // set any attribute values that were entered before adding the file.
        setAttributeValues(issue, intake, context, avMap);
        doGotowizard3(data, context);
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doRemovefile(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getReportingIssue();
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String attachmentIndex;
        boolean fileDeleted = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("file_delete_"))
            {
                attachmentIndex = key.substring(12);
                issue.removeFile(attachmentIndex);
                fileDeleted = true;
            }
        }
        if (fileDeleted)
        {
            scarabR.setConfirmMessage(L10NKeySet.FileDeleted);
        }
        else
        {
            scarabR.setConfirmMessage(L10NKeySet.NoFilesChanged);
        }
        LinkedMap avMap = issue.getModuleAttributeValuesMap(); 
        // set any attribute values that were entered before adding the file.
        setAttributeValues(issue, getIntakeTool(context), context, avMap);
        doGotowizard3(data, context);
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doAddcomment(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getReportingIssue();
        if (intake.isAllValid())
        {
            Attachment attachment = new Attachment();
            Group group = intake.get("Attachment", 
                          attachment.getQueryKey(), false);
            if (group != null)
            {
                 List issues = scarabR.getIssues();
                 if (issues == null || issues.size() == 0)
                 {
                     scarabR.setAlertMessage(L10NKeySet.NoIssuesSelectedToAddComment);
                     searchAndSetTemplate(data, context, 0, MAX_RESULTS, issue, "entry,Wizard2.vm");
                     return;
                 }
                 ActivitySet activitySet = null;
                 for (Iterator itr = issues.iterator(); itr.hasNext();)
                 {
                     Issue prevIssue = (Issue)itr.next();
                     // save the attachment
                     attachment = new Attachment();
                     group.setProperties(attachment);
                     if (attachment.getData() != null 
                         && attachment.getData().trim().length() > 0)
                     {
                         ScarabUser user = (ScarabUser)data.getUser();
                          activitySet = 
                             prevIssue.addComment(activitySet, attachment, user);
                          NotificationManagerFactory.getInstance()
                                .addActivityNotification(
                                        ActivityType.COMMENT_ADDED,
                                        activitySet, issue, null, null, user);                              
                          scarabR.setConfirmMessage(L10NKeySet.CommentAdded);
                     }
                    else
                    {
                        scarabR.setAlertMessage(
                           L10NKeySet.NoTextInCommentTextArea);
                        searchAndSetTemplate(data, context, 0, MAX_RESULTS,
                                             issue, "entry,Wizard2.vm");
                        return;
                    }
                }
            }

            // if there was only one duplicate issue and we just added
            // a comment to it, assume user is done
            String nextTemplate = 
                 ((ScarabUser)data.getUser()).getHomePage();
            if (! searchAndSetTemplate(data, context, 1, MAX_RESULTS, issue, nextTemplate))
            {
                cleanup(data, context);
            }
            else
            {
                intake.remove(group);
            }
            return;
        }
        else 
        {
            // Comment was probably too long.  Repopulate the issue list, so
            // the page can be shown again, and the user can fix the comment.
            searchAndSetTemplate(data, context, 0, MAX_RESULTS, issue, "entry,Wizard2.vm");
        }
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doGotowizard3(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "entry,Wizard3.vm");
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doUsetemplates(RunData data, TemplateContext context)
        throws Exception
    {
        getIntakeTool(context).removeAll();
        String templateId = data.getParameters().getString("select_template_id");
        if (templateId != null && templateId.length() > 0)
        {
            data.getParameters().add("templateId", templateId);
        }
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
private void doRedirect(RunData data, TemplateContext context, 
                            int templateCode, Issue issue)
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String template = null;
        switch (templateCode)
        {
            case 1: 
                if (user.hasPermission(ScarabSecurity.ISSUE__ENTER, 
                                       user.getCurrentModule()))
                {
                    IssueType issueType = issue.getIssueType();
                    template = scarabR.getNextEntryTemplate(issueType);
                    data.getParameters().setString(
                        ScarabConstants.CURRENT_ISSUE_TYPE, 
                        issueType.getQueryKey());
                }
                else 
                {
                    template = user.getHomePage();
                    scarabR.setAlertMessage(
                        L10NKeySet.InsufficientPermissionsToEnterIssues);
                }
                break;
            case 2: 
                if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                                       user.getCurrentModule()))
                {
                    template = "AssignIssue.vm";
                    data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE, 
                                             "ViewIssue.vm");
                    data.getParameters().add("issue_ids", 
                                             issue.getUniqueId());
//                    data.getParameters()
//                        .setString("id", issue.getUniqueId().toString());
                    getIntakeTool(context).removeAll();
                    scarabR.resetAssociatedUsers();
                }
                else 
                {
                    template = user.getHomePage();
                    scarabR.setAlertMessage(
                        L10NKeySet.InsufficientPermissionsToAssignIssues);
                }
                break;
            case 3: 
                if (user.hasPermission(ScarabSecurity.ISSUE__VIEW, 
                                       user.getCurrentModule()))
                {
                    template = "ViewIssue.vm";
                    data.getParameters()
                        .setString("id",issue.getUniqueId().toString());
                }
                else 
                {
                    template = user.getHomePage();
                    scarabR.setAlertMessage(
                        L10NKeySet.InsufficientPermissionsToViewIssues);
                }
                break;
            case 4: 
                template = user.getHomePage();
                break;
            case 5: 
                if (user.hasPermission(ScarabSecurity.ISSUE__VIEW, 
                                       user.getCurrentModule()))
                {
                    template = "ViewIssue.vm";
                    data.getParameters()
                        .setString("id",issue.getUniqueId().toString());
                    data.getParameters()
                        .setString("tab","3"); // comment tab == 3
                    data.getUser().setTemp(ScarabConstants.TAB_KEY, "3");
                }
                else 
                {
                    template = user.getHomePage();
                    scarabR.setAlertMessage(
                        L10NKeySet.InsufficientPermissionsToViewIssues);
                }
                break;
        } 
        setTarget(data, template);
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doStart(RunData data, TemplateContext context)
        throws Exception
    {
        cleanOutStaleIssue(data, context);
    }
              
// in java/org/tigris/scarab/actions/ReportIssue.java
static void cleanOutStaleIssue(RunData data, TemplateContext context)
        throws Exception
    {
        String key = data.getParameters()
            .getString(ScarabConstants.REPORTING_ISSUE);
        ScarabUser user = (ScarabUser)data.getUser();
        if (key != null) 
        {
            data.getParameters().remove(ScarabConstants.REPORTING_ISSUE);
            user.setReportingIssue(key, null);
        }
        //user.setHomePage("home,EnterNew.vm");
    }
              
// in java/org/tigris/scarab/actions/SetHomePage.java
public void doPerform(RunData data, TemplateContext context) throws Exception
    {
        String target = data.getTarget();
        //TODO [HD] Maybe this hard coded reference shall be 
        //          parametrized at some day. (refactoring candidate).
        if ("ModuleNotReady.vm".equals(target)) 
        {
            Log.get()
                .debug("Setting homepage to ModuleNotReady.vm was avoided");
        }
        else 
        {
            ((ScarabUser)data.getUser()).setHomePage(target);
        }
    }
              
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
public void doRequestroles(RunData data, TemplateContext context)
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        ScarabUser user = (ScarabUser)data.getUser();
        SecurityAdminTool scarabA = getSecurityAdminTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);

        // List roles = scarabA.getNonRootRoles();
        List groups = Arrays.asList(scarabA.getGroups());

        Iterator gi = groups.iterator();

        String autoApproveRoleSet=null;
        String waitApproveRoleSet=null;
        
        while (gi.hasNext()) 
        {
            ScarabModule module = ((ScarabModule)gi.next());
            String[] autoRoles = module.getAutoApprovedRoles();
            String roleName = data.getParameters().getString(module.getModuleId().toString());
            AccessControlList acl = user.getACL();
            Role requiredRoleForRequests = module.getRequiredRole();
            boolean bRoleRequestable = requiredRoleForRequests == null || acl.hasRole(requiredRoleForRequests, module);
            if (roleName != null && roleName.length() > 0 && bRoleRequestable) 
            {
                boolean autoApprove = Arrays.asList(autoRoles).contains(roleName);
                if (autoApprove) 
                {
                    Role role = TurbineSecurity.getRole(roleName);
                    
                    TurbineSecurity.grant(user, module, role);

                    // TODO: Needs to be refactored into the Users system?
                    ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.GET_ACL);
                    ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable)role, module);

                    autoApproveRoleSet = addToRoleSet(autoApproveRoleSet,module, roleName);
                }
                else 
                {
                    deleteRoleRequests(user, module);
                    // '0' role really means 'remove request' from module
                    if (!roleName.equals("0"))
                    {
                        try
                        {
                            sendNotification(module, user, roleName); 
                        }
                        catch(Exception e)
                        {
                            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.CouldNotSendNotification,e);
                            scarabR.setAlertMessage(l10nMessage);
                        } 
                        PendingGroupUserRole pend = new PendingGroupUserRole();
                        pend.setGroupId(module.getModuleId());
                        pend.setUserId(user.getUserId());
                        pend.setRoleName(roleName);
                        pend.save();
                        waitApproveRoleSet = addToRoleSet(waitApproveRoleSet,module, roleName);
                    }
                }                
            }
        }

        if (autoApproveRoleSet != null)
        {
            SimpleSkipFiltering htmlSet = new SimpleSkipFiltering(autoApproveRoleSet+"<br>");
            Localizable msg = new L10NMessage(L10NKeySet.RoleRequestGranted, htmlSet);
            scarabR.setConfirmMessage(msg);                    
        }

        if (waitApproveRoleSet != null)
        {
            SimpleSkipFiltering htmlSet = new SimpleSkipFiltering(waitApproveRoleSet+"<br>");
            Localizable msg = new L10NMessage(L10NKeySet.RoleRequestAwaiting, htmlSet);
            scarabR.setInfoMessage(msg);                    
        }

        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
private void sendNotification(ScarabModule module, ScarabUser user, 
                                  String role)
        throws Exception
    {
        EmailContext econtext = new EmailContext();

        econtext.setModule(module);
        econtext.setUser(user);
        econtext.put("role", role);
                
        // Who can approve this request?
        List approvers = Arrays.asList(module.
            getUsers(ScarabSecurity.USER__APPROVE_ROLES));

        // Which potential approvers has any role in this module?
        List approversWithRole = new ArrayList();
        for(Iterator i = approvers.iterator(); i.hasNext();)
        {
            ScarabUser u = (ScarabUser)i.next();
            if (u.hasAnyRoleIn(module))
            {
                approversWithRole.add(u);
            }
        }

        // If some approvers have role in this module, sent email only to them.
        if (!approversWithRole.isEmpty())
        {
            approvers = approversWithRole;
        }

        Email.sendEmail(econtext, module, 
                               "scarab.email.default", module.getSystemEmail(),
                               approvers, null,
                               "RoleRequest.vm");        
    }
              
// in java/org/tigris/scarab/actions/admin/AppConfigurationSettings.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        boolean customSettingsChanged = false;
        ParameterParser pp = data.getParameters();
        CompositeConfiguration c = (CompositeConfiguration)Turbine.getConfiguration();
        PropertiesConfiguration customSettings =null;
        for (int i = 0;i<c.getNumberOfConfigurations();i++){
            if(c.getConfiguration(i) instanceof PropertiesConfiguration){
                PropertiesConfiguration pc = (PropertiesConfiguration)c.getConfiguration(i);
                if(pc.getFileName().endsWith("custom.properties")){
                    customSettings = pc;
                    break;
                }
            }
        }
 
        if (customSettings==null){
            throw new Exception("custom.properties file was not defined in TurbineConfiguration.xml");
        }
                
        for (Iterator i =
            IteratorUtils.filteredIterator(
                new EnumerationIterator(pp.keys()),
                new StartsWithPredicate("configuration.key."));
            i.hasNext();
            )
        {
            String key = (String) i.next();
            String realKey = pp.getString(key);
            String value = pp.getString("configuration.value." + realKey);
            
            String turbineValue;
            try
            {
            	turbineValue = Turbine.getConfiguration().getString(realKey);
            }
            catch( ConversionException ce)
            {
            	// This happens, if the Turbine Property is not a String.
            	// This has been seen on JBOSS. Since we can't provide any
            	// reasonable value here, ignore the entry and continue.
            	log.warn("Turbine property ["+realKey+"] is not a String value. No update done. (continue)");
            	turbineValue = null;
            }            
            
            if (turbineValue != null && !turbineValue.equals(value))
            {
                Turbine.getConfiguration().setProperty(realKey,value);                
                customSettings.setProperty(realKey,value);
                customSettingsChanged=true;                
            }
            
        }
        if (customSettingsChanged){
            customSettings.save();
        }
        
        
        getScarabRequestTool(context).setConfirmMessage(L10NKeySet.AppConfigurationChangesSaved);
    }
              
// in java/org/tigris/scarab/actions/admin/Approval.java
public void doSubmit(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = (ScarabRequestTool)context
            .get(ScarabConstants.SCARAB_REQUEST_TOOL);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Module module = scarabR.getCurrentModule();
        String globalComment = data.getParameters().getString("global_comment");
       
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String action = null;
        Integer actionWord = null;
        Integer artifact = null;
        String artifactName = null;
        String comment = null;
        ScarabUser toUser = null;
        String userId;
        boolean success = true;

        for (int i =0; i<keys.length; i++)
        {
            action="none";
            key = keys[i].toString();
            if (key.startsWith("query_id_"))
            {
               String queryId = key.substring(9);
               Query query = QueryPeer.retrieveByPK(new NumberKey(queryId));

               action = params.getString("query_action_" + queryId);
               comment = params.getString("query_comment_" + queryId);

               userId = params.getString("query_user_" + queryId);
               toUser = scarabR.getUser(userId);
               artifact = QUERY;
               artifactName = query.getName();

               if (query.getApproved())
               {
                   success = false;
                   boolean isApproved = Scope.MODULE__PK.equals(query.getScopeId());
                   LocalizationKey l10nKey = (isApproved) ?
                       L10NKeySet.ItemAlreadyApproved:L10NKeySet.ItemAlreadyRejected;
                   L10NMessage l10nMessage = new L10NMessage(l10nKey,artifactName);
                   scarabR.setAlertMessage(l10nMessage);
               }
               else
               {
                   if (action.equals(REJECT))
                   {
                       try
                       {
                           query.approve(user, false);
                       }
                       catch (ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                       actionWord = REJECTED;
                   } 
                   else if (action.equals(APPROVE))
                   {
                       try
                       {
                           query.approve(user, true);
                       }
                       catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                       actionWord = APPROVED;
                       }
                       else if (action.equals(COMMENT))
                       {
                           actionWord = COMMENTED; 
                       }
                   }
               }
               else if (key.startsWith("template_id_"))
               {
                   String templateId = key.substring(12);
                   IssueTemplateInfo info = IssueTemplateInfoPeer
                                     .retrieveByPK(new NumberKey(templateId));

               action = params.getString("template_action_" + templateId);
               comment = params.getString("template_comment_" + templateId);

               userId = params.getString("template_user_" + templateId);
               toUser = scarabR.getUser(userId);
               artifact = ISSUE_ENTRY_TEMPLATE;
               artifactName = info.getName();

               if (info.getApproved())
               {
                   success = false;
                   boolean isApproved = Scope.MODULE__PK.equals(info.getScopeId());
                   LocalizationKey l10nKey = (isApproved) ?
                       L10NKeySet.ItemAlreadyApproved:L10NKeySet.ItemAlreadyRejected;
                   L10NMessage l10nMessage = new L10NMessage(l10nKey,artifactName);
                   scarabR.setAlertMessage(l10nMessage);
               }
               else
               {
                   if (action.equals(REJECT))
                   {
                       try
                       {
                           info.approve(user, false);
                       }
                       catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                       actionWord = REJECTED;
                   } 
                   else if (action.equals(APPROVE))
                   {
                       try
                       {
                           info.approve(user, true);
                       }
                       catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                       actionWord = APPROVED;
                   }
                   else if (action.equals(COMMENT))
                   {
                       actionWord = COMMENTED;
                   }
                }
                if (!action.equals("none") && success)
                {
                    // send email
                    EmailContext ectx = new EmailContext();
                    ectx.setUser(user);
                    // add specific data to context for email template
                    ectx.put("artifactIndex", artifact);
                    ectx.put("artifactName", artifactName);
                    ectx.put("actionIndex", actionWord);
                    ectx.put("comment", comment);
                    ectx.put("globalComment", globalComment);

                    String template = Turbine.getConfiguration().
                        getString("scarab.email.approval.template",
                                  "Approval.vm");
                    try
                    {
                        Email.sendEmail(ectx, module, user, 
                                        module.getSystemEmail(), 
                                        toUser, template);
                    }
                    catch (Exception e)
                    {
                        L10NMessage l10nMessage =new L10NMessage(EMAIL_ERROR,e);
                        scarabR.setAlertMessage(l10nMessage);
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/Approval.java
public void doApproveroles(RunData data, TemplateContext context)
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module module = scarabR.getCurrentModule();
        if (((ScarabUser)data.getUser())
            .hasPermission(ScarabSecurity.USER__APPROVE_ROLES, module)) 
        {
            SecurityAdminTool scarabA = getSecurityAdminTool(context);
            List pendings = scarabA.getPendingGroupUserRoles(module);
            Iterator i = pendings.iterator();
            while (i.hasNext()) 
            {
                PendingGroupUserRole pending = (PendingGroupUserRole)i.next();
                ScarabUser user = 
                    ScarabUserManager.getInstance(pending.getUserId());

                String checked = data.getParameters()
                .getString("user_id_"+user.getUserName());

                if(checked != null && checked.equals("on"))
                {
                    String roleName = data.getParameters()
                        .getString(user.getUserName());
                    if (roleName != null && roleName.length() > 0) 
                    {
                        if (roleName.equalsIgnoreCase(l10n.get(L10NKeySet.Deny)))
                        {
                            pending.delete();
                        }
                        else 
                        {
                            Role role = TurbineSecurity.getRole(roleName);
                            try
                            {
                                TurbineSecurity.grant(user, (Group)module, role);

                                // TODO: Needs to be refactored into the Users system?
                                ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.GET_ACL);
                                ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable)role, module);
                            }
                            catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
                            pending.delete();
                        }
                    }
                }
            }
            scarabR.setConfirmMessage(L10NKeySet.AllRolesProcessed);
        }
        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/admin/SetInfoMessage.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        String msg = data.getParameters().getString("msg");
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        if (msg == null || msg.trim().length() == 0) 
        {
            SetInfoMessageValve.setMessage(null);
            scarabR.setInfoMessage(null);
        }
        else 
        {
            SetInfoMessageValve.setMessage(msg);            
            scarabR.setInfoMessage(msg);
        }        
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public boolean doSaveinfo (RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return false;
        }
        IntakeTool intake = getIntakeTool(context);
        Module module = scarabR.getCurrentModule();
        RModuleIssueType rmit = module.getRModuleIssueType(issueType);
        if (rmit == null)
        {
            scarabR.setAlertMessage(L10NKeySet.IssueTypeRemovedFromModule);
            doCancel(data, context);
            return false;
        }
        // Set properties for module-issue type info
        Group rmitGroup = intake.get("RModuleIssueType",
                                        rmit.getQueryKey(), false);
        if (intake.isAllValid())
        {
            boolean nameTaken = false;
            List issueTypes = module.getRModuleIssueTypes();
            if (issueTypes != null)
            {
                Field displayName = rmitGroup.get("DisplayName");
                if (displayName.toString().trim().length() == 0)
                {
                    displayName.setMessage("intake_IssueTypeNameNotAllowedEmpty");
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    return false;
                }
                for (int i=0;i<issueTypes.size();i++)
                {
                    RModuleIssueType tmpRmit = ((RModuleIssueType)issueTypes.get(i));
                    if (tmpRmit.getDisplayName().equals(displayName.toString()) 
                        && !tmpRmit.getIssueTypeId().equals(issueType.getIssueTypeId()))
                    {
                        nameTaken = true;
                        break;
                    }
                }
            }
         
            if (nameTaken) 
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
                rmitGroup.get("DisplayName").setMessage("IssueTypeNameExists");
                return false;
            }
            else
            {
                rmitGroup.setProperties(rmit);
                rmit.save();
                scarabR.setConfirmMessage(DEFAULT_MSG);
            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
            return false;
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public boolean doSavegroups (RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return false;
        }

        Module module = scarabR.getCurrentModule();
        RModuleIssueType rmit = module.getRModuleIssueType(issueType);
        if (rmit == null)
        {
            scarabR.setAlertMessage(L10NKeySet.IssueTypeRemovedFromModule);
            doCancel(data, context);
            return false;
        }
        List attGroups = issueType.getAttributeGroups(module, false);

        int dupeOrder = 2;
        boolean areThereDedupeAttrs = false;

        // Manage attribute groups
        // Only have dedupe if there are more than one active group
        if (issueType.getAttributeGroups(module, true).size() > 1)
        {
            dupeOrder = data.getParameters().getInt("dupe_order");

            // Check that duplicate check is not at the beginning.
            if (dupeOrder == 1)
            {
                scarabR.setAlertMessage(L10NKeySet.CannotPositionDuplicateCheckFirst);
                return false;
            }
            // Check for duplicate sequence numbers
            if (areThereDupeSequences(attGroups, intake, "AttributeGroup",
                   "Order", dupeOrder))
            {
               scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                   l10n.get("AttributeGroups").toLowerCase()));
               return false;
            }
        }

        // Set properties for attribute groups
        for (int i=attGroups.size()-1; i>=0; i--)
        {
            AttributeGroup attGroup = (AttributeGroup)attGroups.get(i);
            Group agGroup = intake.get("AttributeGroup",
                                 attGroup.getQueryKey(), false);
            agGroup.setProperties(attGroup);

            // If an attribute group falls before the dedupe screen,
            // Mark it as a dedupe group
            if (attGroup.getOrder() < dupeOrder)
            {
                areThereDedupeAttrs = true;
                attGroup.setDedupe(true);
                List dedupeGroups = module.
                         getDedupeGroupsWithAttributes(issueType);
                if (!dedupeGroups.contains(attGroup))
                {
                    dedupeGroups.add(attGroup);
                }
            }
            else
            {
                attGroup.setDedupe(false);
            }
            attGroup.save();
        }

            // Set dedupe property for module-issueType
        if (!areThereDedupeAttrs
                || issueType.getAttributeGroups(module, true).size() < 2)
        {
            rmit.setDedupe(false);
        }
        else
        {
            Group rmitGroup = intake.get("RModuleIssueType",
                                        rmit.getQueryKey(), false);
            Field dedupe = rmitGroup.get("Dedupe");
            dedupe.setProperty(rmit);
        }
        rmit.save();
        ScarabCache.clear();
        scarabR.setConfirmMessage(DEFAULT_MSG);

        return true;
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public boolean doSaveuserattributes (RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        boolean success = true;

        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            success = false;
        }
        else if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            success = false;
        }
        else
        {
            Module module = scarabR.getCurrentModule();
            List rmas = module.getRModuleAttributes(issueType, false, "user");
            if (areThereDupeSequences(rmas, intake, "RModuleAttribute",
                                                             "Order", 0))
            {
                scarabR.setAlertMessage(
                    l10n.format("DuplicateSequenceNumbersFound",
                    l10n.get("UserAttributes").toLowerCase()));
                success = false;
            }
            else
            {
                for (Iterator itr = rmas.iterator(); itr.hasNext(); )
                {
                    // Set properties for module-attribute mapping
                    RModuleAttribute rma = (RModuleAttribute)itr.next();
                    Group rmaGroup = intake.get("RModuleAttribute",
                             rma.getQueryKey(), false);
                    // if attribute gets set to inactive, delete dependencies
                    boolean newActive = Boolean.valueOf(rmaGroup.get("Active").
                                                    toString()).booleanValue();
                    boolean oldActive = rma.getActive();
                    if (!newActive && oldActive)
                    {
                        WorkflowFactory.getInstance().
                            deleteWorkflowsForAttribute(
                                      rma.getAttribute(), module, issueType);
                    }
                    rmaGroup.setProperties(rma);
                    rma.save();
                }
                scarabR.setConfirmMessage(DEFAULT_MSG);
            }

        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public AttributeGroup doCreatenewgroup (RunData data, 
                                             TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module module = scarabR.getCurrentModule();
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return null;
        }
        scarabR.setConfirmMessage(DEFAULT_MSG);
        return issueType.createNewGroup(module);
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doDeletegroup (RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        boolean noAGSelected = true;
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }

        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String groupId;
        Module module = scarabR.getCurrentModule();
        List attributeGroups = issueType.getAttributeGroups(module, false);

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("group_action"))
            {
                try
                {
                    groupId = key.substring(13);
                    AttributeGroup ag = AttributeGroupManager
                       .getInstance(new NumberKey(groupId), false); 
                    ag.delete();
                    noAGSelected = false;
                    scarabR.setConfirmMessage(DEFAULT_MSG);  
                    ScarabCache.clear();
                    getIntakeTool(context).removeAll();
                }
                catch (Exception e)
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
                if (attributeGroups.size() -1 < 2)
                {
                    // If there are fewer than 2 attribute groups,
                    // Turn of deduping
                    RModuleIssueType rmit =  module.getRModuleIssueType(issueType);
                    rmit.setDedupe(false);
                    rmit.save();
                }
            }
        }
        if (noAGSelected)
        {
           scarabR.setAlertMessage(L10NKeySet.NoAttributeGroupSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doDeleteuserattribute(RunData data, TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        boolean hasAttributes = false;
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }
        Module module = scarabR.getCurrentModule();
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String attributeId;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("att_delete_"))
            {
               hasAttributes = true;
               attributeId = key.substring(11);
               Attribute attribute = AttributeManager
                   .getInstance(new NumberKey(attributeId), false);

               // Remove attribute - module mapping
               RModuleAttribute rma = module
                   .getRModuleAttribute(attribute, issueType);
               rma.delete();

               // Remove attribute - module mapping from template type
               RModuleAttribute rma2 = module
                   .getRModuleAttribute(attribute,
                   scarabR.getIssueType(issueType.getTemplateId().toString()));
               rma2.delete();
               scarabR.setConfirmMessage(DEFAULT_MSG);
               ScarabCache.clear();
           }
        }
        if(!hasAttributes)
        {
            scarabR.setAlertMessage(L10NKeySet.NoUserAttributeSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doCreatenewuserattribute(RunData data,
                                            TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        Group attGroup = intake.get("Attribute", IntakeTool.DEFAULT_KEY);
        intake.remove(attGroup);
        scarabR.setAttribute(null);
        setTarget(data, getOtherTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doSelectuserattribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }

        Module module = scarabR.getCurrentModule();
        String[] attributeIds = data.getParameters()
                                    .getStrings("attribute_ids");
 
        if (attributeIds == null || attributeIds.length <= 0)
        { 
            scarabR.setAlertMessage(L10NKeySet.SelectAttribute);
            return;
        }
        else
        {        
            for (int i=0; i < attributeIds.length; i++)
            {
                Attribute attribute = 
                    scarabR.getAttribute(new Integer(attributeIds[i]));
                if (attribute != null)
                {
                    // add module-attribute groupings
                    module.addRModuleAttribute(issueType,attribute);
                }
                doCancel(data, context);
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = doSaveinfo(data, context) &&
                              doSavegroups(data, context) &&
                                  doSaveuserattributes(data, context);
        if (success)
        {
            doCancel(data, context);
        }
        //Reset confirm message in case some of the changes got saved
        else
        {
            getScarabRequestTool(context).setConfirmMessage(null);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypes.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        List issueTypes = IssueTypePeer.getAllIssueTypes(false);
        boolean dupe = false;
        boolean saved = false;
        if (intake.isAllValid())
        {
            ScarabRequestTool scarabR = getScarabRequestTool(context);
            for (int i=0; i<issueTypes.size(); i++)
            {
                IssueType issueType = (IssueType)issueTypes.get(i);
                Group group = intake.get("IssueType", issueType.getQueryKey());
                // make sure name is unique
                Field field = group.get("Name");
                String name = field.toString();
                if (IssueTypePeer.isUnique(name, issueType.getIssueTypeId())) 
                {
                    group.setProperties(issueType);
                    issueType.save();
                    ScarabCache.clear();
                    saved = true;
                }
                else 
                {
                    dupe = true;
                    field.setMessage("Duplicate");
                }
            }
            if (dupe)
            {
                scarabR.setAlertMessage(
                    l10n.get("ChangesResultDuplicateNames"));
            }
            else if (saved)
            {
                scarabR.setConfirmMessage(
                    l10n.get(DEFAULT_MSG));
            }
            else
            {
                scarabR.setInfoMessage(
                    l10n.get(NO_CHANGES_MADE));
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypes.java
public void doCopy(RunData data, TemplateContext context)
        throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key;
        String id;
        IssueType issueType;
        boolean didCopy = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
                id = key.substring(7);
                issueType = IssueTypeManager.getInstance(new Integer(id));
                if (issueType != null)
                {
                    issueType.copyIssueType();
                    didCopy = true;
                }
            }
        }
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (didCopy)
        {
            scarabR.setConfirmMessage(l10n.get("GlobalArtifactTypeCopied"));
        }
        else
        {
            scarabR.setInfoMessage(l10n.get(NO_CHANGES_MADE));
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypes.java
public void doDelete(RunData data, TemplateContext context)
        throws Exception
    {
        String key = null;
        String id = null;
        IssueType issueType = null;
        boolean deleted = false;
        boolean hasIssues = false;
        boolean immutable = false;
        Object[] keys = data.getParameters().getKeys();
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IntakeTool intake = getIntakeTool(context);
        for (int i =0; i<keys.length; i++)
        {
             key = keys[i].toString();
             if (key.startsWith("action_"))
             {
                id = key.substring(7);
                issueType = IssueTypeManager.getInstance(new Integer(id));
                if (issueType != null)
                {
                    Group group = intake.get("IssueType", issueType.getQueryKey());
                    Field field = group.get("Name");
                    if (issueType.isSystemDefined())
                    {
                        field.setMessage("CannotDeleteSystemSpecifiedIssueType");
                        immutable = true;
                    }
                    else if (issueType.hasIssues())
                    {
                        field.setMessage("IssueTypeHasIssues");
                        hasIssues = true;
                    }
                    else
                    {
                        issueType.setDeleted(true);
                        issueType.save();
                        deleted = true;
                    }
                }
            }
        }
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        if (immutable)
        {
            scarabR.setAlertMessage(l10n.get("CannotDeleteSystemSpecifiedIssueType"));
        }
        else if (hasIssues)
        {
            scarabR.setAlertMessage(l10n.get("CannotDeleteIssueTypesWithIssues"));
        }
        else if (deleted)
        {
            scarabR.setConfirmMessage(l10n.get("GlobalIssueTypesDeleted"));
        }
        else
        {
            scarabR.setInfoMessage(l10n.get(NO_CHANGES_MADE));
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypes.java
public void doUndelete(RunData data, TemplateContext context)
        throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key;
        String id;
        IssueType issueType;
        boolean saved = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
                id = key.substring(7);
                issueType = IssueTypeManager.getInstance(new Integer(id));
                if (issueType != null)
                {
                    issueType.setDeleted(false);
                    issueType.save();
                    saved = true;
                }
            }
        }
        if (saved)
        {
            getScarabRequestTool(context)
                .setConfirmMessage(
                getLocalizationTool(context)
                .get("GlobalIssueTypesUnDeleted"));
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doAdduser(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        ScarabUser su = null;
        
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid())
        {
            Object user = data.getUser()
                .getTemp(ScarabConstants.SESSION_REGISTER);
            Group register = null;
            if (user != null && user instanceof ScarabUser)
            {
                register = intake.get("Register",
                                      ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                register = intake.get("Register",
                                      IntakeTool.DEFAULT_KEY, false);
            }
            
            su  = (ScarabUser) ScarabUserManager.getInstance();
            su.setUserName(register.get("UserName").toString());
            su.setFirstName(register.get("FirstName").toString());
            su.setLastName(register.get("LastName").toString());
            su.setEmail(register.get("Email").toString());
            su.setPassword(register.get("Password").toString().trim());

            try
            {
                if (ScarabUserImplPeer.checkExists(su))
                {
                    su = ScarabUserManager.reactivateUserIfDeleted(su);
                    if(su == null)
                    {
                        setTarget(data, template);
                        scarabR.setAlertMessage(L10NKeySet.UsernameExistsAlready);
                        data.getParameters().setString("errorLast","true");
                        data.getParameters().setString("state","showadduser");
                        return;
                    }
                }
                else
                {
                    su.createNewUser();
                }
            
                // if we got here, then all must be good...

                ScarabUserImpl.confirmUser(register.get("UserName").toString());
                // force the user to change their password the first time they login
                su.setPasswordExpire(Calendar.getInstance());
                Localizable msg = new L10NMessage(L10NKeySet.UserCreated,register.get("UserName").toString());
                scarabR.setConfirmMessage(msg);
                data.getParameters().setString("state","showadduser");
                data.getParameters().setString("lastAction","addeduser");
                
                setTarget(data, nextTemplate);
                return;
            }
            catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
        }
        else
        {
            data.getParameters().setString("state","showadduser");
            data.getParameters().setString("lastAction","");
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doEdituser(RunData data, TemplateContext context) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        ScarabUser su = null;
        
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid())
        {
            Object user = data.getUser()
                .getTemp(ScarabConstants.SESSION_REGISTER);
            Group register = null;
            if (user != null && user instanceof ScarabUser)
            {
                register = intake.get("Register",
                                          ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                register = intake.get("Register",
                                      IntakeTool.DEFAULT_KEY, false);
            }
            
            
            // if we got here, then all must be good...

            String username = data.getParameters().getString("username");
            su = ScarabUserManager.getInstance(username);
            try
            {
                if ((su != null) && (register != null))
                {
                    // update the first name, last name, email
                    // Turbine's security service does not allow
                    // changing the username, this is considered the
                    // defining info of a particular user.  SCB197 is
                    // a request to make this information modifiable.
                    su.setFirstName(register.get("FirstName").toString());
                    su.setLastName(register.get("LastName").toString());
                    su.setEmail(register.get("Email").toString());
                    su.setConfirmed(data.getParameters().getString("accountStatus"));
                    ScarabUserManager.putInstance((ScarabUserImpl)su);
                    TurbineSecurity.saveUser(su);
                    ScarabUserManager.getMethodResult().remove( 
                        ScarabUserManager.SCARAB_USER_MANAGER,
                        ScarabUserManager.GET_INSTANCE, username 
                    );
                    //
                    // Fix: SCB1065
                    // I think this fix really belongs in Turbine, but
                    // I'm not going to touch that code. So here's a 
                    // workaround.
                    //
                    User userInSession = data.getUser(); 
                    if (userInSession.getUserName().equals(username))
                    {
                        //
                        // The current user is trying to modify their
                        // own details. Update the user object in the
                        // session with the new values otherwise the
                        // old ones will be saved back to the database
                        // when the user logs out, or the session times
                        // out.
                        //
                        userInSession.setFirstName(su.getFirstName());
                        userInSession.setLastName(su.getLastName());
                        userInSession.setEmail(su.getEmail());
                        userInSession.setConfirmed(su.getConfirmed());
                    }


                    
                    String password;
                    String passwordConfirm;

                    String generatePassword = data.getParameters().getString("generate-password");
                    if(generatePassword!=null && generatePassword.equalsIgnoreCase("on"))
                    {
                        password = passwordConfirm = PasswordGenerator.generate();
                    }
                    else
                    {
                        password = register.get("NPassword").toString();
                        passwordConfirm = register.get("NPasswordConfirm").toString();                        
                    }
                        
                    if (!password.equals(""))
                    {
                        if (password.equals(passwordConfirm))
                        {
                            TurbineSecurity.forcePassword(su, password);
                            su.setPasswordExpire(Calendar.getInstance());
                            TurbineSecurity.saveUser(su);
                            ScarabUserManager.getMethodResult().remove(
                                ScarabUserManager.SCARAB_USER_MANAGER, 
                                ScarabUserManager.GET_INSTANCE, username 
                            );
                            User me = data.getUser();
                            try
                            {
                                data.setUser(su);
                                ForgotPassword.sendNotificationEmail(context, su, password);
                            }
                            catch(Exception e)
                            {
                                Localizable msg = new L10NMessage(L10NKeySet.ExceptionEmailFailure,e);
                                scarabR.setAlertMessage(msg);
                            }
                            data.setUser(me);
                        }
                        else
                        /* !password.equals(passwordConfirm) */
                        {
                            scarabR.setAlertMessage(L10NKeySet.PasswordsDoNotMatch);
                            return;
                        }
                    }
                    
                    
                    
                    Localizable msg = new L10NMessage(L10NKeySet.UserChangesSaved, username);
                    scarabR.setConfirmMessage(msg);
                    data.getParameters().setString("state", "showedituser");
                    data.getParameters().setString("lastAction", "editeduser");
                    
                    setTarget(data, nextTemplate);
                    return;
                }
                else
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UserNotRetrieved, username);
                    scarabR.setAlertMessage(msg);
                    data.getParameters().setString("state", "showedituser");                    
                }
            }
            catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }   
        }
        else
        {
            data.getParameters().setString("state","showedituser");
            data.getParameters().setString("lastAction","");
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doDeleteuser(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        User user = null;
        String username = data.getParameters().getString("username");
        User userInSession = data.getUser(); 
        if (userInSession.getUserName().equals(username)){
            scarabR.setAlertMessage(L10NKeySet.UserCanNotDeleteSelf);
            return;
        }
        try
        {
            
            user = ScarabUserManager.getInstance(username);
            user.setConfirmed(ScarabUser.DELETED);
            TurbineSecurity.saveUser(user);
            ScarabUserManager.getMethodResult().remove(
                ScarabUserManager.SCARAB_USER_MANAGER,
                ScarabUserManager.GET_INSTANCE, username
            );
            List lista = (List)data.getUser().getTemp("userList");
            if (lista != null)
                lista.set(lista.indexOf(user), user);
            
            Localizable msg = new L10NMessage(L10NKeySet.UserDeleted, username);
            scarabR.setConfirmMessage(msg);
            data.getParameters().setString("state", "showedituser");
            data.getParameters().setString("lastAction", "editeduser");
            
            setTarget(data, nextTemplate);
            return;
            
           
        }
        catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }        
       
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doRoles(RunData data, TemplateContext context)
        throws Exception
    {
        String username = data.getParameters().getString("username");
        User user = ScarabUserManager.getInstance(username);
        
        AccessControlList acl = ((ScarabUser)user).getACL();
        
        // Grab all the Groups and Roles in the system.
        org.apache.fulcrum.security.entity.Group[] groups = TurbineSecurity.getAllGroups().getGroupsArray();
        Role[] roles = TurbineSecurity.getAllRoles().getRolesArray();
        
        for (int i = 0; i < groups.length; i++)
        {
            String groupName = groups[i].getName();
            
            for (int j = 0; j < roles.length; j++)
            {
                String roleName = roles[j].getName();
                String groupRole = groupName + roleName;
                
                String formGroupRole = data.getParameters().getString(groupRole);
                
                if (formGroupRole != null && !acl.hasRole(roles[j], groups[i]))
                {
                    TurbineSecurity.grant(user, groups[i], roles[j]);
                    // TODO: Needs to be refactored into the Users system?
                    ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.HAS_ROLE_IN_MODULE,
                    		(Serializable) roles[j], (Module)groups[i]);
                    
                }
                else if (formGroupRole == null && acl.hasRole(roles[j], groups[i]))
                {
                    TurbineSecurity.revoke(user, groups[i], roles[j]);
                    // TODO: Needs to be refactored into the Users system?
                    ScarabUserManager.getMethodResult().remove( user, ScarabUserManager.HAS_ROLE_IN_MODULE,
                    		(Serializable) roles[j], (Module)groups[i]);
                }
            }
        }
        // TODO: Needs to be refactored into the Users system?
        ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.GET_ACL);
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doGotoedituser(RunData data, TemplateContext context)
        throws Exception
    {
        String userName = data.getParameters().getString("username");
        if ((userName != null) && (userName.length() > 0))
        {
            data.getParameters().setString("state","showedituser");
            setTarget(data, "admin,EditUser.vm");
        }
        else
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.UserSelect);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doGotoeditroles(RunData data, TemplateContext context)
        throws Exception
    {
        String userName = data.getParameters().getString("username");
        if ((userName != null) && (userName.length() > 0))
        {
            setTarget(data, "admin,EditUserRoles.vm");
        }
        else
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.UserSelect);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doGotodeleteuser(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,DeleteUser.vm");
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doGotoadduser(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,AddUser.vm");
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doSearch(RunData data, TemplateContext context)
        throws Exception
    {
        String searchField = data.getParameters().getString("searchField");
        String searchCriteria = data.getParameters().getString("searchCriteria");
        String orderByField = data.getParameters().getString("orderByField");
        String ascOrDesc = data.getParameters().getString("ascOrDesc");
        String resultsPerPage= data.getParameters().getString("resultsPerPage");
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        scarabR.setGlobalUserSearchParam("searchField", searchField);
        scarabR.setGlobalUserSearchParam("searchCriteria", searchCriteria);
        scarabR.setGlobalUserSearchParam("orderByField", orderByField);
        scarabR.setGlobalUserSearchParam("ascOrDesc", ascOrDesc);
        scarabR.setGlobalUserSearchParam("resultsPerPage", resultsPerPage);
        
        setTarget(data, "admin,ManageUserSearch.vm");
    }
              
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doSearch(data, context);
    }
              
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
public synchronized void doSave (RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        Module module = scarabR.getCurrentModule();
        List rmits = module.getRModuleIssueTypes();
        int navCount = 0;
        Group rmitGroup = null;

        if (areThereDupeSequences(rmits, intake, "RModuleIssueType", "Order", 0))
        {
            scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                                     l10n.get("IssueTypes").toLowerCase()));
            return;
        }

        if (intake.isAllValid())
        {
            for (int i=0;i < rmits.size(); i++)
            {
                RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
                rmitGroup = intake.get("RModuleIssueType", 
                                 rmit.getQueryKey(), false);
                Field display = rmitGroup.get("Display");

                if (display.toString().equals("true"))
                {
                    navCount++;
                }
                if (navCount > 5)
                {
                   scarabR.setAlertMessage(l10n.get("NavIssueTypeLimit"));
                   return;
                }
            }
            for (int i=0;i < rmits.size(); i++)
            {
                RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
                rmitGroup = intake.get("RModuleIssueType", 
                                 rmit.getQueryKey(), false);
                rmitGroup.setProperties(rmit);
                rmit.save();
                
                // TODO: document the reason for this
                String pageNum = data.getParameters().getString("pageNum","1");
                data.getParameters().add("pageNum", pageNum);
            }
            ScarabCache.clear();
        } 
    }
              
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
public void doSelectissuetype(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        Module module = scarabR.getCurrentModule();

        if (issueType.getIssueTypeId() == null)
        {
            scarabR.setAlertMessage(l10n.get("SelectIssueType"));
        }
        else if (module.getRModuleIssueType(issueType) != null)
        {
            scarabR.setAlertMessage(l10n.get("IssueTypeAlreadyAssociated"));
        }
        else
        {
            module.addIssueType(issueType);
            ScarabCache.clear();
            scarabR.setConfirmMessage(l10n.get("IssueTypeAddedToModule"));
            setTarget(data, "admin,ManageArtifactTypes.vm");            
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
public void doCreateartifacttype(RunData data, TemplateContext context)
        throws Exception
    {
        data.getParameters().remove("issueTypeId");
        setTarget(data, getOtherTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
public void doDeletemoduleissuetype (RunData data, 
                                          TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        ParameterParser params = data.getParameters();
        Module module = scarabR.getCurrentModule();
        Object[] keys = params.getKeys();
        String key;
        String issueTypeId;
        List rmits = module.getRModuleIssueTypes();

        boolean foundOne = false;
        boolean success = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
                if (rmits.size() < 1)
                {
                    scarabR.setAlertMessage(l10n.get("CannotZeroIssueType"));
                    break;
                }
                else
                {
                    issueTypeId = key.substring(7);
                    IssueType issueType = scarabR.getIssueType(issueTypeId);
                    RModuleIssueType rmit = module.getRModuleIssueType(issueType);
                    Group rmitGroup = getIntakeTool(context).get("RModuleIssueType", 
                                 rmit.getQueryKey(), false);
                    Field field = rmitGroup.get("DisplayName");
                    if (issueType != null)
                    {
                        foundOne = true;
                        if (issueType.getLocked())
                        {
                            //scarabR.setAlertMessage(l10n.get("LockedIssueType"));
                            field.setMessage("LockedIssueType");
                        }
                        else if (issueType.hasIssues(module))
                        {
                            scarabR.setAlertMessage(l10n.get("CannotDeleteIssueTypesWithIssues"));
                            field.setMessage("IssueTypeHasIssues");
                        }
                        else
                        {
                            try
                            {
                                // delete module-issue type mappings
                                rmit.delete(user);
                                success = true;
                                // FIXME! need proper cache invalidation
                                module.getNavIssueTypes().remove(issueType);
                            }
                            catch (Exception e)
                            {
                                scarabR.setAlertMessage(
                                    l10n.get("CannotDeleteIssueType"));
                                Log.get().warn(
                                    "Could not delete issue type", e);
                            }
                        }

                    }
                }
            }
         
         }
         if (success)
         { 
            String msg = l10n.get("SelectedIssueTypesRemovedFromModule");
            scarabR.setConfirmMessage(msg);
         }
         if (!foundOne)
         {
             String msg = l10n.get("SelectIssueTypeToDeleteFromModule");
             scarabR.setAlertMessage(msg);
         }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public boolean doSaveinfo(RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = getScarabRequestTool(context).getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return false;
        }
        Group group = intake.get("IssueType", issueType.getQueryKey());
        Field field = group.get("Name");
        String name = field.toString();
        Integer id = issueType.getIssueTypeId();

        if (intake.isAllValid()) 
        {
            if (id == null)
            {
                // Create new issue type
                // make sure name is unique
                if (IssueTypePeer.isUnique(name, null)) 
                {
                    group.setProperties(issueType);
                    issueType.setParentId(IssueTypePeer.getRootKey());
                    issueType.save();
                    
                    // Create default attribute groups
                    issueType.createDefaultGroups();

                    // Create template type.
                    IssueType template = new IssueType();
                    template.setName(issueType.getName() + " Template");
                    template.setParentId(issueType.getIssueTypeId());
                    template.save();
                }
                else 
                {
                    scarabR.setAlertMessage(l10n.get("IssueTypeNameExists"));
                }
            }
            else
            {
                // Edit existing issue type
                if (IssueTypePeer.isUnique(name, id)) 
                {
                    // Cannot delete an issue type that has issues 
                    Field deleted = group.get("Deleted");
                    if (deleted != null && deleted.toString().equals("true") 
                        && issueType.hasIssues())
                    {
                        scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
                        deleted.setMessage("IssueTypeHasIssues");
                        success = false;
                    }
                    else
                    {
                        group.setProperties(issueType);
                        issueType.save();
                        scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
                    }
                }
                else 
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.get("IssueTypeNameExists"));
                }
            }
        }
        else
        {
            scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
            success = false;
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public boolean doSavegroups (RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return false;
        }
        List attGroups = issueType.getAttributeGroups(null, false);
        int nbrAttGroups = attGroups.size();
        int dupeOrder = 2;

        // Manage attribute groups, only seeking sequence collisions
        // when there is more than one active group.
        if (issueType.getAttributeGroups(null, true).size() > 1)
        {
            dupeOrder = data.getParameters().getInt("dupe_order");

            // Check that duplicate check is not at the beginning.
            if (dupeOrder == 1)
            {
                scarabR.setAlertMessage(l10n.get("CannotPositionDuplicateCheckFirst"));
                return false;
            }

            // Check for duplicate sequence numbers
            if (areThereDupeSequences(attGroups, intake, "AttributeGroup",
                    "Order", dupeOrder))
            {
                scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                    l10n.get("AttributeGroups").toLowerCase()));
                return false;
            }
        }

        if (intake.isAllValid())
        {
            boolean areThereDedupeAttrs = false;
            // Set properties for attribute groups
            for (int i = nbrAttGroups - 1; i >= 0; i--)
            {
                AttributeGroup attGroup = (AttributeGroup)attGroups.get(i);
                Group agGroup = intake.get("AttributeGroup",
                                 attGroup.getQueryKey(), false);
                agGroup.setProperties(attGroup);

                // If an attribute group falls before the dedupe
                // screen, mark it as a dedupe group.  Even groups
                // which are currently empty of attributes should be
                // marked as such, as attributes may later be added to
                // them.
                areThereDedupeAttrs = attGroup.getOrder() < dupeOrder;
                attGroup.setDedupe(areThereDedupeAttrs);
                attGroup.save();
            }
            if (areThereDedupeAttrs)
            {
                Group itGroup = intake.get("IssueType",
                                        issueType.getQueryKey(), false);
                Field dedupe = itGroup.get("Dedupe");
                dedupe.setProperty(issueType);
            }
            issueType.save();
            ScarabCache.clear();
            scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
        }
        else
        {
            scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
            success = false;
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doCreatenewuserattribute(RunData data, 
                                          TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        Group attGroup = intake.get("Attribute", IntakeTool.DEFAULT_KEY);
        intake.remove(attGroup);
        scarabR.setAttribute(null);
        setTarget(data, getOtherTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public AttributeGroup doCreatenewgroup (RunData data, 
                                             TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return null;
        }
        scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
        return issueType.createNewGroup();
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doDeletegroup (RunData data, TemplateContext context)
        throws Exception
    {
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String groupId;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        List attributeGroups = issueType.getAttributeGroups(null, false);

        boolean atLeastOne = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("group_action"))
            {
                atLeastOne = true;
                groupId = key.substring(13);
                AttributeGroup ag = AttributeGroupManager
                    .getInstance(new NumberKey(groupId), false);
                if (Log.get().isDebugEnabled()) 
                {
                    Log.get().info("Deleting attribute group: " + groupId);
                }
                ag.delete();
                ScarabCache.clear();
            }
        }
        if (atLeastOne) 
        {
            scarabR.setConfirmMessage(l10n.get("SelectedGroupDeleted"));
            // TODO: this logic seems off by one to me (jmcnally), need
            // to document why this is not so, as it seems to work
            if (attributeGroups.size() -1 < 2)
            {
                // If there are fewer than 2 attribute groups,
                // Turn off deduping
                issueType.setDedupe(false);
                issueType.save();
            }
        }
        else 
        {
            scarabR.setAlertMessage(l10n.get("NoGroupSelected"));  
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doSelectuserattribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        String[] attributeIds = data.getParameters()
                                    .getStrings("attribute_ids");
 
        if (attributeIds == null || attributeIds.length <= 0)
        { 
            scarabR.setAlertMessage(l10n.get("SelectAttribute"));
            return;
        }
        else
        {        
            for (int i=0; i < attributeIds.length; i++)
            {
                Attribute attribute = 
                    scarabR.getAttribute(new Integer(attributeIds[i]));
                if (attribute != null)
                {
                    // add issuetype-attribute groupings
                    issueType.addRIssueTypeAttribute(attribute);
                }
                doCancel(data, context);
                ScarabCache.clear();
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doDeleteuserattribute(RunData data, TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ParameterParser params = data.getParameters();
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        Object[] keys = params.getKeys();
        String key;
        String attributeId;
        boolean atLeastOne = false;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("att_delete_"))
            {
               atLeastOne = true;
               attributeId = key.substring(11);
               Attribute attribute = AttributeManager
                   .getInstance(new NumberKey(attributeId), false);

               // Remove attribute - issue type mapping
               RIssueTypeAttribute ria = issueType
                   .getRIssueTypeAttribute(attribute);
               try
               {
                   ria.delete();
               }
               catch (Exception e)
               {
                   scarabR.setAlertMessage(l10n.get(NO_PERMISSION_MESSAGE));
               }

               scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
               ScarabCache.clear();
           }
        }        
        if (!atLeastOne)
        {
           scarabR.setAlertMessage(l10n.get("NoAttributesSelected"));
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public boolean doSaveuserattributes (RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType =  scarabR.getIssueType();
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return false;
        }
        if (intake.isAllValid())
        {
            List rias = issueType.getRIssueTypeAttributes(false,"user");
            if (areThereDupeSequences(rias, intake, "RIssueTypeAttribute",
                                          "Order", 0))
            {
                scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                    l10n.get("UserAttributes").toLowerCase()));
                return false;
            }
            for (int i=0; i < rias.size(); i++)
            {
                // Set properties for issue type-attribute mapping
                RIssueTypeAttribute ria = (RIssueTypeAttribute)rias.get(i);
                Group riaGroup = intake.get("RIssueTypeAttribute",
                                 ria.getQueryKey(), false);
                riaGroup.setProperties(ria);
                ria.save();
            }
            getScarabRequestTool(context)
                .setConfirmMessage(l10n.get(DEFAULT_MSG));
        }
        return true;
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = doSaveinfo(data, context) &&
                              doSavegroups(data, context) &&
                                  doSaveuserattributes(data, context);
        if (success)
        {
            doCancel(data, context);
        }
        //Reset confirm message in case some of the changes got saved
        else
        {
            getScarabRequestTool(context).setConfirmMessage(null);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doGotoothertemplate(RunData data,
                                     TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType =  scarabR.getIssueType();
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        super.doGotoothertemplate(data,context);
    }
              
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public synchronized void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Attribute attribute = scarabR.getAttribute();
        IssueType issueType =  scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(getLocalizationTool(context)
                                       .get("SystemSpecifiedIssueType"));
            return;
        }
        if (intake.isAllValid())
        {
            List rios = issueType.getRIssueTypeOptions(attribute, false);
            // Check for duplicate sequence numbers
            if (areThereDupeSequences(rios, intake,
                    "RIssueTypeOption","Order", 0))
            {
                scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                         l10n.get("AttributeOptions").toLowerCase()));
                return;
            }

            if (rios != null)
            {
                for (int i=rios.size()-1; i>=0; i--) 
                {
                    RIssueTypeOption rio = (RIssueTypeOption)rios.get(i);
                    Group rioGroup = intake.get("RIssueTypeOption",
                                     rio.getQueryKey(), false);
                    rioGroup.setProperties(rio);
                    rio.save();
                    ScarabCache.clear();
                    scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
                }
            }
        }
        if (attribute.isOptionAttribute())
        {
            List options = issueType.getRIssueTypeOptions(attribute, true);
            if (options == null || options.isEmpty())
            {
                RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
                if (ria.getRequired())
                {
                    ria.setRequired(false);        
                    ria.save();
                    scarabR.setAlertMessage(l10n.get("DeletedOptionsFromRequiredAttribute"));
                }
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public void doDeleteissuetypeoptions(RunData data,
                                          TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        IssueType issueType = scarabR.getIssueType();
        Attribute attribute = scarabR.getAttribute();

        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String optionId;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
               optionId = key.substring(7);
               AttributeOption option = AttributeOptionManager
                  .getInstance(new Integer(optionId));

               RIssueTypeOption rio = issueType.getRIssueTypeOption(option);
               List rios = issueType.getRIssueTypeOptions(attribute,
                                                          false);
               try
               {
                   rio.delete(user, scarabR.getCurrentModule());
                   rios.remove(rio);
               }
               catch (Exception e)
               {
                   scarabR.setAlertMessage(ScarabConstants.NO_PERMISSION_MESSAGE);
               }
               scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
            }
        }        
        if (attribute.isOptionAttribute())
        {
            List options = issueType.getRIssueTypeOptions(attribute, true);
            if (options == null || options.isEmpty())
            {
                RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
                if (ria.getRequired())
                {
                    ria.setRequired(false);        
                    ria.save();
                    scarabR.setAlertMessage(l10n.get("DeletedOptionsFromRequiredAttribute"));
                }
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public void doSelectissuetypeoption(RunData data, 
                                         TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        String[] optionIds = data.getParameters().getStrings("option_ids");
 
        if (optionIds == null || optionIds.length <= 0)
        {
            scarabR.setAlertMessage(l10n.get("SelectOption"));
            return;
        }
        else
        {        
            for (int i=0; i < optionIds.length; i++)
            { 
                AttributeOption option = null;
                try
                {
                    option = scarabR.getAttributeOption(new Integer(optionIds[i]));
                    issueType.addRIssueTypeOption(option);
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                }
            }
            doCancel(data, context);
            scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
        }
    }
              
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public void doGotoothertemplate(RunData data,
                                     TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType =  scarabR.getIssueType();
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        super.doGotoothertemplate(data,context);
    }
              
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public void doDone( RunData data, TemplateContext context )
        throws Exception
    {
        doSave(data, context);
        if (getScarabRequestTool(context).getAlertMessage() == null)
        {
            doCancel( data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributes.java
public void doCreatenew(RunData data, TemplateContext context)
        throws Exception
    {
        String nextTemplate = data.getParameters().getString(
            ScarabConstants.OTHER_TEMPLATE, "admin, GlobalAttributeEdit.vm");
        setTarget(data, nextTemplate);

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        scarabR.setAttribute(AttributeManager.getInstance());
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributes.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        List userAttrs = AttributePeer.getAttributes("user");
        for (int i=0; i<userAttrs.size(); i++)
        {
            Attribute attr = (Attribute)userAttrs.get(i);
            Group attrGroup = intake.get("Attribute", attr.getQueryKey());
            if (attrGroup != null)
            {
                attrGroup.setProperties(attr);
                attr.save();
            }
        }
        ScarabCache.clear();
        getScarabRequestTool(context).setConfirmMessage(getLocalizationTool(context).get(DEFAULT_MSG));
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributes.java
public synchronized void doCopy(RunData data, TemplateContext context)
        throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key = null;
        String id = null;
        Attribute attribute = null;
        boolean didCopy = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
               id = key.substring(7);
               attribute = AttributeManager.getInstance(new Integer(id));
               Attribute newAttribute = attribute
                  .copyAttribute((ScarabUser)data.getUser());
               newAttribute.save();
               didCopy = true;
            }
        }
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        if (didCopy)
        {
            scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
        }
        else
        {
            scarabR.setInfoMessage(l10n.get(NO_CHANGES_MADE));
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doGotoaddrole(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,AddRole.vm");
    }
              
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doGotoeditrole(RunData data, TemplateContext context)
        throws Exception
    {
        checkParamValidity(data, context, "admin,EditRole.vm");
    }
              
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doGotodeleterole(RunData data, TemplateContext context)
        throws Exception
    {
        checkParamValidity(data, context, "admin,DeleteRole.vm");
    }
              
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doAddrole(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        if (intake.isAllValid())
        {
            Object user = data.getUser().getTemp(ScarabConstants.SESSION_REGISTER);
            
            Group editRole = null;
            if (user != null && user instanceof ScarabUser)
            {
                editRole = intake.get("EditRole", ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                editRole = intake.get("EditRole", IntakeTool.DEFAULT_KEY, false);
            }
            String name = editRole.get("RoleName").toString();
            
            try
            {        
                Role role = TurbineSecurity.getNewRole(null);
                role.setName(name);
                
                TurbineSecurity.addRole(role);

                String msg = l10n.format("RoleCreated", name);
                getScarabRequestTool(context).setConfirmMessage(msg);

                data.getParameters().setString("name", name);
                doGotoeditrole(data, context);
            }
            catch (EntityExistsException eee)
            {
                String msg = l10n.format("RoleExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doEditrole(RunData data, TemplateContext context)
        throws Exception
    {
        /*
         * Grab the role we are trying to update.
         */
        String name = data.getParameters().getString("name");
        checkParamValidity(data, context, null);
        Role role = TurbineSecurity.getRole(name);
        
        /*
         * Grab the permissions for the role we are
         * dealing with.
         */
        PermissionSet rolePermissions = role.getPermissions();
        
        /*
         * Grab all the permissions.
         */
        Permission[] permissions = TurbineSecurity.getAllPermissions()
            .getPermissionsArray();
        
        String roleName = role.getName();
        
        for (int i = 0; i < permissions.length; i++)
        {
            String permissionName = permissions[i].getName();
            String rolePermission = roleName + permissionName;
            
            String formRolePermission = data.getParameters().getString(rolePermission);
            Permission permission = TurbineSecurity.getPermission(permissionName);
            
            
            if (formRolePermission != null && !rolePermissions.contains(permission))
            {
                /*
                 * Checkbox has been checked AND the role doesn't already
                 * contain this permission. So assign the permission to
                 * the role.
                 */
                
                role.grant(permission);
            }
            else if (formRolePermission == null && rolePermissions.contains(permission))
            {
                /*
                 * Checkbox has not been checked AND the role
                 * contains this permission. So remove this
                 * permission from the role.
                 */
                role.revoke(permission);
            }
        }
        
        ScarabUserManager.getMethodResult().clear();
    }
              
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doDeleterole(RunData data, TemplateContext context)
        throws Exception
    {
        /*
         * Grab the role we are trying to delete.
         */
        String name = data.getParameters().getString("name");
        Role role = TurbineSecurity.getRole(name);
        TurbineSecurity.removeRole(role);
        
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        String msg = l10n.format("RoleDeleted", name);
        getScarabRequestTool(context).setConfirmMessage(msg);
        setTarget(data, data.getParameters()
                      .getString(ScarabConstants.NEXT_TEMPLATE, "admin,ManageRoles.vm"));
    }
              
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doCancel(data,context);
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public boolean doSaveattributedata(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        boolean success = true;
        boolean confirmDelete = false;

        if (intake.isAllValid())
        {
            Attribute attr = scarabR.getAttribute();

            Group attrGroup = null;
            boolean isDupe = false;
            Field attributeName = null;
            Field description = null;
            if (attr.getAttributeId() == null)
            {
                // new attribute
                attrGroup = intake.get("Attribute", IntakeTool.DEFAULT_KEY);
                attr.setCreatedBy(((ScarabUser)data.getUser()).getUserId());
                attr.setCreatedDate(new Date());
            }
            else
            {
                attrGroup = intake.get("Attribute", attr.getQueryKey());
            }
            attributeName = attrGroup.get("Name");
            description = attrGroup.get("Description");
            isDupe = Attribute.checkForDuplicate(attributeName.toString().trim(), attr);

            // Check for blank attribute names.
            if (attributeName.toString().trim().length() == 0)
            {
                attributeName.setMessage("intake_AttributeNameNotAllowedEmpty");
                scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
                success = false;
            }
            if (description.toString().trim().length() == 0)
            {
                description.setMessage("intake_AttributeDescriptionNotAllowedEmpty");
                scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
                success = false;
            }
            // Check for duplicate attribute names.
            else if (isDupe)
            {
                scarabR.setAlertMessage(
                    l10n.get("CannotCreateDuplicateAttribute"));
                success = false;
            }
            else
            {
                // if deleting attribute, and attribute is associated
                // With modules or issue types, give confirmation.
                if (!attr.getDeleted() && 
                    attrGroup.get("Deleted").toString().equals("true") &&
                    (attr.hasModuleMappings() ||
                     attr.hasGlobalIssueTypeMappings()))
                {
                    context.put("deleting", "deleting");
                    confirmDelete=true;
                    success = false;
                }
                for (int i = 0; i < attrGroup.getFieldNames().length; i++)
                {
                    String fieldName = attrGroup.getFieldNames()[i];
                    if (!fieldName.equals("Deleted") || !confirmDelete)
                    {
                        attrGroup.get(fieldName).setProperty(attr);
                    }
                }
                attr.save();
                mapAttribute(data,context);
                if (success)
                {
                    scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
                    AttributeManager.clear();
                }
            }
        }
        else
        {
          success = false;
          scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public void doDeleteattribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Attribute attr = scarabR.getAttribute();
        if (attr.isSystemDefined())
        {
            scarabR.setAlertMessage(getLocalizationTool(context).get
                                  ("CannotDeleteSystemSpecifiedAttribute"));
            return;
        }
        if (attr.getAttributeId() != null)
        {
            attr.deleteModuleMappings(); 
            attr.deleteIssueTypeMappings();
            attr.setDeleted(true);
            attr.save();
            scarabR.setConfirmMessage(getLocalizationTool(context).get(DEFAULT_MSG));  
            setTarget(data, getCancelTemplate(data));
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public synchronized boolean 
        doSaveoptions(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = (IntakeTool)context
           .get(ScarabConstants.INTAKE_TOOL);
        ScarabRequestTool scarabR = (ScarabRequestTool)context
           .get(ScarabConstants.SCARAB_REQUEST_TOOL);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        if (intake.isAllValid()) 
        {
            // get the Attribute that we are working on
            Attribute attribute = scarabR.getAttribute();
            if (log().isDebugEnabled()) 
            {
                log().debug("doSaveoptions for attribute id=" + 
                            attribute.getAttributeId());
            }
            Group attGroup = intake.get("Attribute", attribute.getQueryKey());
            String attributeTypeId = attGroup.get("TypeId").toString();
            AttributeType attributeType = AttributeTypeManager
                .getInstance(new NumberKey(attributeTypeId), false);

            if (attributeType.getAttributeClass().getName()
                                                 .equals("select-one"))
            {
                if (log().isDebugEnabled()) 
                {
                    log().debug("attribute id=" + attribute.getAttributeId() + 
                                " is an option attribute");
                }
                boolean somethingSaved = false;
                // get the list of ParentChildAttributeOptions's 
                // used to display the page
                List pcaoList = attribute.getParentChildAttributeOptions();
                // Check for duplicate sequence numbers
                if (areThereDupeSequences(pcaoList, intake,
                        "ParentChildAttributeOption","PreferredOrder", 0))
                {
                    scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                         l10n.get("AttributeOptions").toLowerCase()));
                    return false;
                }
                for (int i=pcaoList.size()-1; i>=0; i--) 
                {
                    ParentChildAttributeOption pcao = 
                        (ParentChildAttributeOption)pcaoList.get(i);

                    if (pcao.getChildOption().isSystemDefined()) 
                    {
                        if (Log.get().isDebugEnabled()) 
                        {
                            Log.get().debug("PCAO(" + pcao + 
                                ") is used by a system defined issue type");
                        }                        
                    }
                    else 
                    {
                    Group pcaoGroup = intake.get("ParentChildAttributeOption", 
                                                  pcao.getQueryKey());

                    // there could be errors here so catch and re-display
                    // the same screen again.
                    Integer currentParentId = null;
                    try
                    {
                        // store the currentParentId
                        currentParentId = pcao.getParentId();
                        // map the form data onto the objects
                        pcaoGroup.setProperties(pcao);
 
                        // If deleting, delete mappings with module 
                        if (pcao.getDeleted())
                        {
                            AttributeOption option = AttributeOptionPeer
                                .retrieveByPK(pcao.getOptionId());
                            if (log().isDebugEnabled()) 
                            {
                                log().debug("deleting mappings for option id=" + 
                                            option.getOptionId());
                            }
                            option.deleteModuleMappings();
                            option.deleteIssueTypeMappings();
                        }

                        List ancestors = null;
                        try
                        {
                            ancestors= pcao.getAncestors();
                        }
                        catch (Exception e)
                        {
                            scarabR.setAlertMessage(
                               l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
                        if (ancestors.contains(pcao.getOptionId()))
                        {
                            scarabR.setAlertMessage(
                                l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
                    
                        // save the PCAO now..
                        pcao.save();

                        // if we are changing the parent id's, then we want
                        // to remove the old one after the new one is created
                        if (!pcao.getParentId().equals(currentParentId))
                        {
                            if (log().isDebugEnabled()) 
                            {
                                log().debug("removing parent relationship for option id=" + 
                                            pcao.getOptionId() + ", old parent id="
                                            + currentParentId);
                            }
                            ROptionOption.doRemove(currentParentId, 
                                                   pcao.getOptionId());
                        }

                       // also remove the group because we are re-displaying
                       // the form data and we want it fresh
                       intake.remove(pcaoGroup);
                       if (log().isDebugEnabled()) 
                       {
                           log().debug("Saved pcao for attribute id=" + 
                                       pcao.getAttributeId() + " and option id="
                                       + pcao.getOptionId());
                       }
                       somethingSaved = true;
                    }
                    catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
                }
                }
                // all existing attribute options are checked
                
                if (somethingSaved)
                {
                    scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
                    AttributeManager.clear();
                }

                // handle adding the new line.
                ParentChildAttributeOption newPCAO = 
                    ParentChildAttributeOption.getInstance();
                Group newPCAOGroup = intake.get("ParentChildAttributeOption", 
                                                newPCAO.getQueryKey());
                if (newPCAOGroup != null) 
                {
                    log().debug("checking for a new pcao");
                    try
                    {
                        // assign the form data to the object
                        newPCAOGroup.setProperties(newPCAO);
                        // only add a new entry if there is a name defined
                        if (newPCAO.getName() != null && newPCAO.getName().length() > 0)
                        {
                            // save the new PCAO
                            newPCAO.setAttributeId(attribute.getAttributeId());
                            try
                            {
                                newPCAO.save();
                                if (log().isDebugEnabled()) 
                                {
                                    log().debug("Saved NEW pcao for attribute id="
                                                + newPCAO.getAttributeId() + " and option id="
                                                + newPCAO.getOptionId());
                                }
                                pcaoList.add(newPCAO);
                                IssueType issueType = null;
                                AttributeOption option = null;

                                // If user came from editing a module,
                                // Add new option to module.
                                String cancelTemplate = getCancelTemplate(data);
                                if (cancelTemplate != null
                                    && (cancelTemplate.equals("admin,AttributeOptionSelect.vm")
                                        || cancelTemplate.equals("admin,GlobalAttributeOptionSelect.vm")))
                                {
                                    issueType = scarabR.getIssueType();
                                    option = scarabR.getAttributeOption(newPCAO.getOptionId());
                                    if (log().isDebugEnabled()) 
                                    {
                                        log().debug("cancelTemplate=" + 
                                                    cancelTemplate + 
                                                    " issuetype id=" + 
                                                    issueType.getIssueTypeId() + 
                                                    " and option id=" + 
                                                    option.getOptionId());
                                    }
                                }
                                // add new option to current module
                                if (cancelTemplate.equals("admin,AttributeOptionSelect.vm"))
                                {
                                    scarabR.getCurrentModule()
                                       .addAttributeOption(issueType, option);
                                    data.getParameters().setString(
                                         ScarabConstants.CANCEL_TEMPLATE, 
                                         "admin,ModuleAttributeEdit.vm");
                                    if (log().isDebugEnabled()) 
                                    {
                                        log().debug("Adding mapping to module id" 
                                                    + scarabR.getCurrentModule()
                                                    .getModuleId());
                                    }
                                }
                                // add new option to current issue type
                                else if (cancelTemplate.equals("admin,GlobalAttributeOptionSelect.vm"))
                                {
                                    issueType.addRIssueTypeOption(option);
                                    data.getParameters().setString(
                                         ScarabConstants.CANCEL_TEMPLATE, 
                                         "admin,IssueTypeAttributeEdit.vm");
                                    log().debug("Adding mapping to issuetype");
                                }
                                scarabR.setConfirmMessage(
                                    l10n.get("AttributeOptionAdded") + 
                                    l10n.get(DEFAULT_MSG));
                            }
                            catch (Exception e)
                            {
                                log().error("Error adding attribute option:", e);
                                scarabR.setAlertMessage("Error adding attribute option:" + l10n.getMessage(e));
                            }
                        }
                    }
                    catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }

                    // now remove the group to set the page stuff to null
                    intake.remove(newPCAOGroup);
                    attribute.buildOptionsMap();
                    ScarabCache.clear();
                }
            }
        }
        return true;
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        log().debug("called doDone");
        boolean success = doSaveattributedata(data, context);
        if (getScarabRequestTool(context).getAttribute().isOptionAttribute())
        {
            success = doSaveoptions(data, context);
            updatetransitiondata(data, context);            
        }
        if (success)
        {
            //if "deleting" is set, do not call 'doCancel' since the control
            //should go to 'confirm delete' page.
            if(!"deleting".equals(context.get("deleting")))
            {
                log().debug("calling doCancel");
                doCancel(data, context);
            }
        }
        //Reset confirm message in case some of the changes got saved
        else
        {
            getScarabRequestTool(context).setConfirmMessage(null);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
private void mapAttribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String lastTemplate = getCancelTemplate(data);
        Attribute attribute = scarabR.getAttribute();

        if (log().isDebugEnabled())
        {
            log().debug("called mapAttribute; lastTemplate=" + lastTemplate +
                        " and attribute id=" + attribute.getAttributeId());
        }
        if (lastTemplate != null && attribute.getAttributeId() != null)
        {
            // Add attribute to group
            if (lastTemplate.equals("admin,AttributeGroupEdit.vm") ||
                lastTemplate.equals("admin,GlobalAttributeGroupEdit.vm"))
            {
                // Add attribute to group
                String groupId = data.getParameters().getString("groupId");
                if (groupId != null)
                {
                    if (log().isDebugEnabled())
                    {
                        log().debug("Adding attribute to group id=" + groupId);
                    }
                    AttributeGroup attributeGroup = scarabR.getAttributeGroup(groupId);
                    if(!attributeGroup.hasAttribute(attribute))
                    {
                        scarabR.getAttributeGroup(groupId).addAttribute(attribute);
                        scarabR.setConfirmMessage(l10n.get("AttributeAdded"));
                    }
                }
            }
            else if (lastTemplate.equals("admin,ArtifactTypeEdit.vm"))
            {
            Module currentModule = scarabR.getCurrentModule();
                IssueType issueType = scarabR.getIssueType();
                if (log().isDebugEnabled())
                {
                    log().debug("Adding attribute to module id=" +
                                currentModule.getModuleId());
                }
                // Add user attribute to module
                if (!attribute.hasMapping(currentModule, issueType))
                {
                      currentModule.addRModuleAttribute(issueType,attribute);
                      scarabR.setConfirmMessage(l10n.get("AttributeAdded"));
                }

            }
            else if (lastTemplate.equals("admin,GlobalArtifactTypeEdit.vm"))
            {
                IssueType issueType = scarabR.getIssueType();
                if (log().isDebugEnabled())
                {
                    log().debug("Assuming user attribute and adding to "
                                + "issuetype id "
                                + issueType.getIssueTypeId());
                }
                // Add user attribute to issue type
                if (!attribute.hasGlobalMapping(issueType))
                {
                   issueType.addRIssueTypeAttribute(attribute);
                   scarabR.setConfirmMessage(l10n.get("AttributeAdded"));
                }
            }
            ScarabCache.clear();
        }

    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public void doCancel(RunData data, TemplateContext context)
        throws Exception
    {
        String lastTemplate = getCancelTemplate(data);
        if (lastTemplate != null)
        {
            setTarget(data, lastTemplate);
        }
        else
        {
            super.doCancel(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public boolean doSavetransitiondata(RunData data, TemplateContext context)
            throws Exception
    {
        boolean bRdo = false;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Attribute attr = scarabR.getAttribute();
        Integer attributeId = attr.getAttributeId();
        if (!data.getParameters().getString("trans_new_RoleId").equals("choose") &&
                !data.getParameters().getString("trans_new_FromId").equals("choose") &&
                !data.getParameters().getString("trans_new_ToId").equals("choose"))
        {
            Integer roleId = data.getParameters().getInteger("trans_new_RoleId");
            Integer fromId = data.getParameters().getInteger("trans_new_FromId");
            Integer toId = data.getParameters().getInteger("trans_new_ToId");

            if (roleId.intValue() == -1)
                roleId = null;
            if (fromId.intValue() == -1)
                fromId = null;
            if (toId.intValue() == -1)
                toId = null;
            try
            {
                Transition transition = new Transition();
                transition.setRoleId(roleId);
                transition.setFromOptionId(fromId);
                transition.setToOptionId(toId);
                transition.setAttributeId(attributeId);
                attr.addTransition(transition);
                attr.save();
                transition.save();
                TransitionManager.getMethodResult().remove(attr, TransitionManager.GET_ALL_TRANSITIONS);
                bRdo = true;
            }
            catch (TorqueException te)
            {
                this.log().error("doSavetransitiondata(): " + te);
            }            
        }
        updatetransitiondata(data, context);
        
        return bRdo;
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public boolean doDeletetransitiondata(RunData data, TemplateContext context)
            throws Exception
    {
        boolean bRdo = false;
        boolean bChanges = false;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Attribute attr = scarabR.getAttribute();
        List transitions = attr.getTransitions();
        Iterator iter = transitions.iterator();

        // Will store the transitions to delete in order to avoid the
        // ConcurrentModificationException??
        List toDelete = new ArrayList();
        try
        {
            while (iter.hasNext())
            {
                Transition trans = (Transition) iter.next();
                boolean bDelete = data.getParameters().getBoolean(
                        "trans_delete_" + trans.getTransitionId());
                if (bDelete)
                {
                    bChanges = true;
                    toDelete.add(trans);
                    AttributeManager.clear();
                }
            }
            iter = toDelete.iterator();
            while (iter.hasNext())
            {
                Transition trans = (Transition) iter.next();
                transitions.remove(trans);
                TransitionPeer.doDelete(trans);
            }
            if (toDelete.size() > 0)
            {
                TransitionManager.getMethodResult().remove(attr, TransitionManager.GET_ALL_TRANSITIONS);
            }
            bRdo = true;
        }
        catch (TorqueException te)
        {
            this.log().error("doDeleteTransition(): " + te);
        }
        scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
        return bRdo;
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
private void updatetransitiondata(RunData data, TemplateContext context) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Attribute attr = scarabR.getAttribute();
        List transitions = attr.getTransitions();
        boolean bChanges = false;
        for (Iterator iter = transitions.iterator(); iter.hasNext(); )
        {
            // Update the "disabled if blocked" value
            Transition trans = (Transition)iter.next();
            boolean value = data.getParameters().getBoolean("trans_disabled_value_" + trans.getTransitionId());
            boolean newValue = data.getParameters().getBoolean("trans_disabled_new_" + trans.getTransitionId());
            if (value != newValue)
            {
                trans.setDisabledIfBlocked(newValue);
                trans.save();
                bChanges = true;
            }
        }
        if (bChanges)
        {
            TransitionManager.getMethodResult().remove(attr, TransitionManager.GET_ALL_TRANSITIONS);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
public synchronized void doSave (RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module module = scarabR.getCurrentModule();
        IssueType issueType = scarabR.getIssueType();

        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(l10n.get("LockedIssueType"));
            return;
        }
        Attribute attribute = scarabR.getAttribute();
        RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
        if (ria != null && ria.getLocked())
        {
            scarabR.setAlertMessage(l10n.format("LockedAttribute", attribute.getName()));
            return;
        }

        
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid())
        {
            List rmos = module.getRModuleOptions(attribute, issueType, false);
            // Check for duplicate sequence numbers
            if (areThereDupeSequences(rmos, intake, "RModuleOption", "Order", 0))

            {
                scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                         l10n.get("AttributeOptions").toLowerCase()));
                return;
            }
            if (rmos != null)
            {
                for (int i=rmos.size()-1; i>=0; i--) 
                {
                    RModuleOption rmo = (RModuleOption)rmos.get(i);
                    Group rmoGroup = intake.get("RModuleOption",
                                     rmo.getQueryKey(), false);
                    // if option gets set to inactive, delete dependencies
                    if (rmoGroup != null)
                    {
                        String newActive = rmoGroup.get("Active").toString();
                        String oldActive = String.valueOf(rmo.getActive());
                        if (newActive.equals("false") && oldActive.equals("true"))
                        {
                            WorkflowFactory.getInstance().deleteWorkflowsForOption(
                                                          rmo.getAttributeOption(),
                                                          module, issueType);
                        }
                        rmoGroup.setProperties(rmo);
                        rmo.save();
                    }
                    ScarabCache.clear();
                    scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
                }
            }
        }
        if (attribute.isOptionAttribute())
        {
            List options = module.getRModuleOptions(attribute, issueType, true);
            if (options == null || options.isEmpty())
            {
                RModuleAttribute rma = module.getRModuleAttribute(attribute, issueType);
                if (rma.getRequired())
                {
                    rma.setRequired(false);        
                    rma.save();
                    scarabR.setAlertMessage(l10n.get("DeletedOptionsFromRequiredAttribute"));
                }
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
public void doDeleteattributeoptions(RunData data,
                                          TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(l10n.get("LockedIssueType"));
            return;
        }
        Attribute attribute = scarabR.getAttribute();
        RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
        if (ria != null && ria.getLocked())
        {
            scarabR.setAlertMessage(l10n.format("LockedAttribute", attribute.getName()));
            return;
        }

        Module module = scarabR.getCurrentModule();
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String optionId;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
               optionId = key.substring(7);
               AttributeOption option = AttributeOptionManager
                  .getInstance(new Integer(optionId));

               RModuleOption rmo = module.getRModuleOption(option, issueType);
               rmo.delete();

               // Remove option - module mapping from template type
               RModuleOption rmo2 = module.getRModuleOption(option, 
                   scarabR.getIssueType(issueType.getTemplateId().toString()));
               rmo2.delete();
               scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
               ScarabCache.clear();
               getIntakeTool(context).removeAll();
               data.getParameters().add("att_0id", option.getAttribute().getAttributeId().toString());
            }
        }        
        if (attribute.isOptionAttribute())
        {
            List options = module.getRModuleOptions(attribute, issueType, true);
            if (options == null || options.isEmpty())
            {
                RModuleAttribute rma = module.getRModuleAttribute(attribute, issueType);
                if (rma.getRequired())
                {
                    rma.setRequired(false);        
                    rma.save();
                    scarabR.setAlertMessage(l10n.get("DeletedOptionsFromRequiredAttribute"));
                }
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
public void doSelectattributeoption(RunData data, 
                                         TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(l10n.get("LockedIssueType"));
            return;
        }
        Attribute attribute = scarabR.getAttribute();
        RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
        if (ria != null && ria.getLocked())
        {
            scarabR.setAlertMessage(l10n.format("LockedAttribute", attribute.getName()));
            return;
        }
        Module module = scarabR.getCurrentModule();

        String[] optionIds = data.getParameters().getStrings("option_ids");
 
        if (optionIds == null || optionIds.length <= 0)
        { 
            scarabR.setAlertMessage(l10n.get("SelectOption"));
            return;
        }
        else
        {        
            for (int i=0; i < optionIds.length; i++)
            {
                AttributeOption option = null;
                try
                {
                    option = scarabR.getAttributeOption(new Integer(optionIds[i]));
                    module.addAttributeOption(issueType, option);
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                }
            }
            ScarabCache.clear();
            scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
            doCancel(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
public void doDone( RunData data, TemplateContext context )
        throws Exception
    {
        doSave(data, context);
        if (getScarabRequestTool(context).getAlertMessage() == null)
        {
            doCancel( data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public boolean doSaveinfo (RunData data, TemplateContext context)
        throws Exception
    { 
        boolean success = true;
        // Set properties for group info
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }
        String groupId = data.getParameters().getString("groupId");
        AttributeGroup ag = AttributeGroupManager
                            .getInstance(new NumberKey(groupId), false);
        Group agGroup = intake.get("AttributeGroup", 
                                    ag.getQueryKey(), false);
        if (!ag.isGlobal() && scarabR.getIssueType().getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return false;
        }
        if (intake.isAllValid())
        {
            agGroup.setProperties(ag);
            ag.save();
            scarabR.setConfirmMessage(DEFAULT_MSG);
        }
        else
        {
            success = false;
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public boolean doSaveattributes (RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IntakeTool intake = getIntakeTool(context);
        IssueType issueType = scarabR.getIssueType();
        Module module = scarabR.getCurrentModule();

        // Check if issue type is system-defined, hence unmodifyable
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }

        String groupId = data.getParameters().getString("groupId");
        AttributeGroup attributeGroup = AttributeGroupManager
                            .getInstance(new NumberKey(groupId), false);
        
        LocalizationKey l10nKey = DEFAULT_MSG;

        // Check if issue type is locked
        if (!attributeGroup.isGlobal() && issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return false;
        }

        // Check for duplicate sequence numbers
        if (areThereDupeSequences(attributeGroup.getRAttributeAttributeGroups(), intake,
                "RAttributeAttributeGroup", "Order", 0))
        {
            scarabR.setAlertMessage(
                l10n.format("DuplicateSequenceNumbersFound",
                l10n.get(L10NKeySet.Attributes).toLowerCase()));
            return false;
        }

        List rmas = attributeGroup.getRModuleAttributes();
        ArrayList lockedAttrs = new ArrayList();

        if (intake.isAllValid())
        {
            // First iterate thru and check for required attributes
            // That have no active options
            Iterator i = rmas.iterator();
            while (i.hasNext()) 
            {
                RModuleAttribute rma = (RModuleAttribute)i.next();
                Group rmaGroup = intake.get("RModuleAttribute", 
                                 rma.getQueryKey(), false);
                Attribute attr = rma.getAttribute();
                if (attr.isOptionAttribute() && rmaGroup.get("Required").toString().equals("true"))
                {
                    List options = module.getRModuleOptions(rma.getAttribute(), issueType, true);
                    if (options == null || options.isEmpty())
                    {
                        scarabR.setAlertMessage(L10NKeySet.CannotRequireAttributeWithNoOptions);
                        success = false;
                    }
                }
            }
            if (success)
            {
                

                // Check whether a module specific statusAttribute was selected
                // and store it in the GLOBAL_PARAMETER table
                String key = "status_attribute_"+issueType.getIssueTypeId();
                String statusAttributeKey = data.getParameters()
                   .getString(key);
                if ( statusAttributeKey != null ) 
                {
                    String attributeId = GlobalParameterManager.getString(key,module);
                    if(attributeId == null || !attributeId.equals(statusAttributeKey))
                    {
                        GlobalParameterManager.setString(key, module, statusAttributeKey);
                    }
                }
                
                
                i = rmas.iterator();
                while (i.hasNext()) 
                {
                    boolean locked = false;
                    // Set properties for module-attribute mapping
                    RModuleAttribute rma = (RModuleAttribute)i.next();
                    Group rmaGroup = intake.get("RModuleAttribute", 
                                     rma.getQueryKey(), false);
                    Attribute attr = rma.getAttribute();

                    // Test to see if attribute is locked
                    RModuleAttribute rmaTest = rma.copy();
                    rmaTest.setModified(false);
                    rmaGroup.setProperties(rmaTest);
                    if (rmaTest.isModified())
                    {
                        RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        if (ria != null &&  ria.getLocked())
                        {
                             lockedAttrs.add(attr);
                             locked = true;
                        }
                    }

                    if (!locked)
                    {
                        // if attribute gets set to inactive, delete dependencies
                        String newActive = rmaGroup.get("Active").toString();
                        String oldActive = String.valueOf(rma.getActive());
                        if (newActive.equals("false") && oldActive.equals("true"))
                        {
                            WorkflowFactory.getInstance()
                                .deleteWorkflowsForAttribute(attr, module, 
                                                             issueType);
                        }
                        rmaGroup.setProperties(rma);
                        String defaultTextKey = data.getParameters()
                          .getString("default_text");
                        if (defaultTextKey != null && 
                             defaultTextKey.equals(rma.getAttributeId().toString())) 
                        {
                            if (!rma.getRequired())
                            {
                                l10nKey = L10NKeySet.ChangesSavedButDefaultTextAttributeRequired;
                                intake.remove(rmaGroup);
                            }
                            rma.setIsDefaultText(true);
                            rma.setRequired(true);
                        }
                        
                        try
                        {
                            rma.save();
                            // Set properties for attribute-attribute group mapping
                            RAttributeAttributeGroup raag = 
                                attributeGroup.getRAttributeAttributeGroup(attr);
                            Group raagGroup = intake.get("RAttributeAttributeGroup", 
                                         raag.getQueryKey(), false);
                            raagGroup.setProperties(raag);
                            raag.save();
                            scarabR.setConfirmMessage(l10nKey);
                        }
                        catch (ScarabLocalizedTorqueException slte) 
                        {
                            String msg = slte.getMessage(l10n);
                            scarabR.setAlertMessage(msg);
                        }
                        catch (TorqueException te) 
                        {
                            String msg = te.getMessage();
                            scarabR.setAlertMessage(msg);
                        }
                    }

                    // If they attempted to modify locked attributes, give message.
                    if (lockedAttrs.size() > 0)
                    {
                        setLockedMessage(lockedAttrs, context);
                    }
                }
            }
        } 
        else
        {
            success = false;
            scarabR.setAlertMessage(L10NKeySet.MoreInformationWasRequired);
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public boolean doSaveglobal (RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String groupId = data.getParameters().getString("groupId");
        AttributeGroup ag = AttributeGroupManager
                            .getInstance(new NumberKey(groupId), false);
        IssueType issueType = scarabR.getIssueType();

        // Check if issue type is system defined, hence unmodifyable
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }
        if (issueType.getIssueTypeId() == null)
        {
            scarabR.setAlertMessage(L10NKeySet.IssueTypeNotFound);
            return false;
        }


        // Check for duplicate sequence numbers
        if (areThereDupeSequences(ag.getRAttributeAttributeGroups(), intake,
                                       "RAttributeAttributeGroup", "Order",0))
        {
            scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                l10n.get("Attributes").toLowerCase()));
            return false;
        }
        String l10nMsg = l10n.get(DEFAULT_MSG);

        if (intake.isAllValid())
        {
            List rias = ag.getRIssueTypeAttributes();

            // first check if there are required attributes
            // Without active options
            Iterator i = rias.iterator();
            while (i.hasNext()) 
            {
                RIssueTypeAttribute ria = (RIssueTypeAttribute)i.next();
                Group riaGroup = intake.get("RIssueTypeAttribute", 
                                 ria.getQueryKey(), false);
                Attribute attr = ria.getAttribute();
                if (attr.isOptionAttribute() && riaGroup.get("Required").toString().equals("true"))
                {
                    List options = issueType.getRIssueTypeOptions(ria.getAttribute(), true);
                    if (options == null || options.isEmpty())
                    if (issueType.getRIssueTypeOptions(attr, true).isEmpty())
                    {
                        scarabR.setAlertMessage(L10NKeySet.CannotRequireAttributeWithNoOptions);
                        success = false;
                    }
                }
            }
            i = rias.iterator();
            if (success)
            {
                while (i.hasNext()) 
                {
                    RIssueTypeAttribute ria = (RIssueTypeAttribute)i.next();
                    Group riaGroup = intake.get("RIssueTypeAttribute", 
                                     ria.getQueryKey(), false);
                    riaGroup.setProperties(ria);
                    String defaultTextKey = data.getParameters()
                        .getString("default_text");
                    if (defaultTextKey != null && 
                         defaultTextKey.equals(ria.getAttributeId().toString())) 
                    {
                        if (!ria.getRequired())
                        {
                            l10nMsg = l10n.get(L10NKeySet.ChangesSavedButDefaultTextAttributeRequired);
                        }
                        ria.setIsDefaultText(true);
                        ria.setRequired(true);
                        intake.remove(riaGroup);
                    }
                    ria.save();

                    // Set properties for attribute-attribute group mapping
                    RAttributeAttributeGroup raag = 
                        ag.getRAttributeAttributeGroup(ria.getAttribute());
                    Group raagGroup = intake.get("RAttributeAttributeGroup",
                                 raag.getQueryKey(), false);
                    raagGroup.setProperties(raag);
                    raag.save();
                }
                scarabR.setConfirmMessage(l10nMsg);
            }
        } 
        else
        {
            success = false;
            scarabR.setAlertMessage(l10nMsg);
        }
        return success;
    }
              
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public void doDeleteattributes(RunData data, TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module module = scarabR.getCurrentModule();
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        String groupId = data.getParameters().getString("groupId");
        AttributeGroup ag = AttributeGroupManager
            .getInstance(new NumberKey(groupId), false);
        boolean hasAttributes = false;

        if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, module))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }
        if (!ag.isGlobal() && issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String attributeId;
        ArrayList lockedAttrs = new ArrayList();

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("att_delete_"))
            {
                hasAttributes = true;
                attributeId = key.substring(11);
                Attribute attribute = AttributeManager
                   .getInstance(new NumberKey(attributeId), false);
                RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
                if (!ag.isGlobal() && ria != null &&  ria.getLocked())
                {
                    lockedAttrs.add(attribute);
                }
                else
                {
                    try
                    {
                        ag.deleteAttribute(attribute, user, module);
                    }
                    catch (ScarabException e)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(e));
                        Log.get().warn(
                            "This is an application error, if it is not permission related.", e);
                    }
                }
            }
        }
        if(!hasAttributes)
        {
            scarabR.setAlertMessage(L10NKeySet.NoAttributeSelected);
        }

        // If there are no attributes in any of the dedupe
        // Attribute groups, turn off deduping in the module
        boolean areThereDedupeAttrs = false;
        List attributeGroups = issueType.getAttributeGroups(module, true);
        if (attributeGroups.size() > 0)
        {
            for (int j=0; j<attributeGroups.size(); j++)
            {
                AttributeGroup agTemp = (AttributeGroup)attributeGroups.get(j);
                if (agTemp.getDedupe() && !agTemp.getAttributes().isEmpty())
                {
                   areThereDedupeAttrs = true;
                }
            }
            if (!areThereDedupeAttrs)
            {
                if (module == null)
                {
                    issueType.setDedupe(false);
                    issueType.save();
                }
                else
                {
                    RModuleIssueType rmit = module.getRModuleIssueType(issueType);
                    rmit.setDedupe(false);
                    rmit.save();
                }
            }
        }

        // If they attempted to modify locked attributes, give message.
        if (lockedAttrs.size() > 0)
        {
            setLockedMessage(lockedAttrs, context);
        }
        ScarabCache.clear();
        if(hasAttributes)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public void doCreatenewglobalattribute(RunData data,
                                            TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        Group attGroup = intake.get("Attribute", IntakeTool.DEFAULT_KEY);
        intake.remove(attGroup);
        scarabR.setAttribute(null);
        setTarget(data, getOtherTemplate(data));
    }
              
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public void doSelectattribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        AttributeGroup ag = scarabR.getAttributeGroup();

        if (!ag.isGlobal() && scarabR.getIssueType().getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }
        String[] attributeIds = data.getParameters()
                                    .getStrings("attribute_ids");
 
        if (attributeIds == null || attributeIds.length <= 0)
        { 
            scarabR.setAlertMessage(L10NKeySet.SelectAttribute);
            return;
        }
        else
        {
            boolean alreadySubmited = false;
            for (int i=0; i < attributeIds.length; i++)
            {
                Attribute attribute =
                    scarabR.getAttribute(new Integer(attributeIds[i]));
                try
                {
                    ag.addAttribute(attribute);
                }
                catch (TorqueException e)
                {
                    alreadySubmited = true;
                    scarabR.setAlertMessage(L10NKeySet.ResubmitError);
                }
            }
            doCancel(data, context);
            if (!alreadySubmited)
            {
                scarabR.setConfirmMessage(DEFAULT_MSG);
            }
        }
    }
              
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public void doDone (RunData data, TemplateContext context)
        throws Exception
    {
        String groupId = data.getParameters().getString("groupId");
        AttributeGroup ag = AttributeGroupManager
                            .getInstance(new NumberKey(groupId), false);
        boolean infoSuccess = doSaveinfo(data, context);
        boolean attrSuccess = false;
        if (ag.isGlobal())
        {
            attrSuccess = doSaveglobal(data, context);
        }
        else
        {
            attrSuccess = doSaveattributes(data, context);
        }
        if (infoSuccess && attrSuccess)
        {
            doCancel(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
private void setLockedMessage (List lockedAttrs, TemplateContext context)
        throws Exception
    {
        StringBuffer buf = new StringBuffer();
        for (int i=0; i<lockedAttrs.size(); i++)
        {
            Attribute attr = (Attribute)lockedAttrs.get(i);
            buf.append(attr.getName());
            if (i == lockedAttrs.size()-1)
            {
                buf.append(".");
            }
            else
            {
                buf.append(",");
            }
        }
        getScarabRequestTool(context).setAlertMessage(getLocalizationTool(context).format("LockedAttributes", buf.toString()));
    }
              
// in java/org/tigris/scarab/actions/admin/UpdateSearchIndex.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        LuceneSearchIndex index = SearchFactory.getInstance();
        
        if(isRunning)
        {
            isRunning = index.isRebuildInProgress();
            
            if(!isRunning)
                scarabR.setConfirmMessage( new L10NMessage( L10NKeySet.SearchIndexUpdated ));               
        }
        else
        {
            index.startRebuild();
            isRunning=true;
        }            

        if(isRunning){
            scarabR.setConfirmMessage( new L10NMessage( L10NKeySet.SearchIndexRebuildInProgress, index.pctRebuildFinished()));
            context.put("updateFrequency", "10" );
            context.put("rebuildInProgress", Boolean.TRUE);
        }

        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/admin/UpdateSearchIndex.java
public void doCancel(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        LuceneSearchIndex index = SearchFactory.getInstance();
        
        index.cancelRebuild();
        scarabR.setConfirmMessage( new L10NMessage( L10NKeySet.SearchIndexRebuildCancelled));
    
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/admin/GlobalEmailSettings.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        ParameterParser pp = data.getParameters();
        String name = null;
        for (int i=0; i < NAMES.length; i++) 
        {
            name = NAMES[i];
            GlobalParameterManager.setBoolean(name, pp.getBoolean(name));
        }
        // Note: name = GlobalParameter.EMAIL_ALLOW_MODULE_OVERRIDE
        if (!GlobalParameterManager.getBoolean(name)) 
        {
            // need to delete module overrides
            String sql = "delete from " + GlobalParameterPeer.TABLE_NAME 
                + " where " + GlobalParameterPeer.NAME + "='" + name 
                + "' and module_id is not null";
            GlobalParameterPeer.executeStatement(sql);
        }
        
        getScarabRequestTool(context).setConfirmMessage(DEFAULT_MSG);
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
public void doDelete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        IntakeTool intake = getIntakeTool(context);
        Group attrGroup = intake.get("ConditionEdit", IntakeTool.DEFAULT_KEY);
        data.getParameters().remove(attrGroup.get("ConditionsArray").getKey());
        updateObject(data, context, null);
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void delete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        int nObjectType = data.getParameters().getInt("obj_type");
        Criteria crit = new Criteria();
        switch (nObjectType)
        {
            case ScarabConstants.TRANSITION_OBJECT:
            	Integer tranId = data.getParameters().getInteger("transition_id");
            	crit.add(ConditionPeer.TRANSITION_ID, tranId);
            	TransitionManager.getMethodResult().remove(TransitionManager.getInstance(tranId), TransitionManager.GET_CONDITIONS);
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, 0);
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, 0);
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
        		crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, data.getParameters().getInt("module_id"));
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, data.getParameters().getInt("issueTypeId"));
        		break;
            case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabRequestTool scarabR = getScarabRequestTool(context);
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.deleteConditions(user, module);
                return;
        }
        ConditionPeer.doDelete(crit);
    	ConditionManager.clear();
    	TransitionManager.clear();
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void updateObject(RunData data, TemplateContext context, Integer aConditions[]) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Integer operator = data.getParameters().getInteger("combineWith");
        switch (data.getParameters().getInt("obj_type"))
        {
            case ScarabConstants.TRANSITION_OBJECT:
                Transition transition = scarabR.getTransition(data.getParameters().getInteger("transition_id"));
            	transition.setConditionsArray(aConditions, operator);
            	transition.save();
            	TransitionManager.getMethodResult().remove(transition, TransitionManager.GET_CONDITIONS);
                AttributeManager.clear();        
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                Attribute attribute = scarabR.getAttribute(data.getParameters().getInteger("attId"));
            	attribute.setConditionsArray(aConditions, operator);
            	attribute.save();
                AttributeManager.clear();        
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
            	RModuleAttribute rma = RModuleAttributePeer.retrieveByPK(data.getParameters().getInteger("moduleId"), data.getParameters().getInteger("attId"), data.getParameters().getInteger("issueTypeId"));
                rma.setConditionsArray(aConditions, operator);
                RModuleAttributeManager.clear();
                ConditionManager.clear();
                rma.save(); /** TODO: do we need it? **/
                AttributeManager.clear();        
        		break;
        	case ScarabConstants.BLOCKED_MODULE_ISSUE_TYPE_OBJECT:
        	    RModuleIssueType rmit = RModuleIssueTypePeer.retrieveByPK(scarabR.getCurrentModule().getModuleId(), data.getParameters().getInteger("issuetypeid"));
        		rmit.setConditionsArray(aConditions, operator);
        	    rmit.save();
        	    RModuleIssueTypeManager.clear();
        	    ConditionManager.clear();
                AttributeManager.clear();        
        	    break;
        	case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.saveConditions(user, module, aConditions, operator);
        	    break;
        }
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
public void doSave(RunData data, TemplateContext context) throws Exception
    {
        this.delete(data, context);
        IntakeTool intake = getIntakeTool(context);
        Group attrGroup = intake.get("ConditionEdit", IntakeTool.DEFAULT_KEY);
        Integer aConditions[] = ((Integer[])attrGroup.get("ConditionsArray").getValue());
        updateObject(data, context, aConditions);
            
    }
              
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
public void doCancel(RunData data, TemplateContext context) throws Exception
    {
        String lastTemplate = getCancelTemplate(data);
        if (lastTemplate != null)
        {
            setTarget(data, lastTemplate);
        }
        else
        {
            super.doCancel(data, context);
        }
    }
              
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doGotoaddpermission(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,AddPermission.vm");
    }
              
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doGotodeletepermission(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,DeletePermission.vm");
    }
              
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doAddpermission(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        if (intake.isAllValid())
        {
            Object user = data.getUser().getTemp(ScarabConstants.SESSION_REGISTER);
            
            Group editPermission = null;
            if (user != null && user instanceof ScarabUser)
            {
                editPermission = intake.get("EditPermission", ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                editPermission = intake.get("EditPermission", IntakeTool.DEFAULT_KEY, false);
            }
            String name = editPermission.get("PermissionName").toString();
            
            try
            {        
                Permission permission = TurbineSecurity.getNewPermission(null);
                permission.setName(name);
                
                TurbineSecurity.addPermission(permission);
                data.getParameters().setString("lastAction", "addedpermission");
                String msg = l10n.format("PermissionCreated", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
            catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
        }       
    }
              
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doDeletepermission(RunData data, TemplateContext context)
        throws Exception
    {
        String name = data.getParameters().getString("name");
        Permission permission = TurbineSecurity.getPermission(name);    
        TurbineSecurity.removePermission(permission);

        ScarabUserManager.getMethodResult().remove( ScarabUserManager.SCARAB_USER_IMPL, ScarabUserManager.ACL_HAS_PERMISSION );
        
        ScarabUserManager.getMethodResult().clear();

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String msg = l10n.format("PermissionDeleted", name);
        getScarabRequestTool(context).setConfirmMessage(msg);
        setTarget(data, data.getParameters().getString(ScarabConstants.NEXT_TEMPLATE, "admin,ManagePermissions.vm"));
        
    }
              
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doCancel(RunData data, TemplateContext context) throws Exception
    {
        setTarget(data, data.getParameters()
                      .getString(ScarabConstants.CANCEL_TEMPLATE, "admin,AdminIndex.vm"));
    }
              
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doCancel(data,context);
    }
              
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
public void doDeletenotifications( RunData data, TemplateContext context)
    throws Exception
    {                
        deleteMarkedEntries(data, context);
    }
              
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
private void deleteMarkedEntries(RunData data, TemplateContext context)
            throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key;
        String queryId;
        ScarabUser user = (ScarabUser) data.getUser();

        // loop over all notification ids contained in the
        // current parameter set. These notifications will
        // be removed from the Notificaiton List now without
        // rollback!
        for (int i = 0; i < keys.length; i++)
        {
            key = keys[i].toString();
            if (key.toLowerCase().startsWith("notificationid_"))
            {
                Object[] pkeys = extractPrimarykeys(key);
                Long tid    = (Long)pkeys[0];
                Integer cid = (Integer)pkeys[1];
                Integer rid = (Integer)pkeys[2];
                NotificationStatus ns = NotificationStatusPeer.retrieveByPK(tid,cid,rid);
                ns.markDeleted();
            }
        }
    }
              
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
public void doCustomize( RunData data, TemplateContext context)
    throws Exception
    {                
        customize(data, context);
    }
              
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
private void customize(RunData data, TemplateContext context) 
        throws Exception
    {
        String key;
        ScarabUser   user   = (ScarabUser) data.getUser();
        Integer userId = user.getUserId();

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module module = scarabR.getCurrentModule();
        Integer moduleId = module.getModuleId();
        
        
        // The ruleMap contains all rules for this user and this module
        NotificationRulePeer nfp = new NotificationRulePeer();
        Map<String, List<NotificationRule>> ruleMap = NotificationRulePeer.getCustomization(moduleId, userId);

        // The list of activityTypes
        ScarabGlobalTool scarabG = getScarabGlobalTool(context);
        List activityTypeList = scarabG.getAllNotificationTypeCodes();
        
        Iterator iter = activityTypeList.iterator();
        while(iter.hasNext())
        {
            String code = (String)iter.next();
            boolean theStatus      = data.getParameters().getBoolean(code+":status");
            boolean theSendSelf    = data.getParameters().getBoolean(code+":self");
            boolean theSendFailure = data.getParameters().getBoolean(code+":fail");
            Integer managerId      = NotificationManagerFactory.getInstance().getManagerId();
            
            NotificationRule rule = null;
            List<NotificationRule> rules = ruleMap.get(code);
            if(rules.size() == 0)
            {    
                rule = NotificationRule.createDefaultRule
                (
                    moduleId,
                    userId,
                    managerId,
                    code
                );
            }
            else
            {
                rule = rules.get(0);
            }
            markUpdateOrNew(rule);
            
            // adjust the new attribute values
            rule.setSendSelf(theSendSelf);
            rule.setSendFailures(theSendFailure);
            rule.setFilterState(theStatus);
            
            // finally modify in database.
            modifyInDatabase(rule);
        }
        scarabR.setConfirmMessage(L10NKeySet.ChangesSaved);
    }
              
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
private void modifyInDatabase(NotificationRule rule) throws TorqueException, Exception
    {
        if (equalsDefaultCustomization(rule))
        {
            if (rule.isNew())
            {
                // don't need to create this rule
            }
            else
            {
                // can safely remove this rule
                ObjectKey pk = rule.getPrimaryKey();
                NotificationRulePeer.doDelete(pk);
            }
         }
        else
        {
            // need to store this rule
            rule.save();
        }
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doAdd(RunData data, TemplateContext context) 
        throws Exception
    {
        int returnCode = 0;
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module module = scarabR.getCurrentModule();
        ParameterParser params = data.getParameters();
        StringBuffer msg = new StringBuffer();
        String[] userIds = params.getStrings(ADD_USER);
        Map<String,String> userAttributes = new HashMap<String,String>();
        if (userIds != null)
        {
            for (int i=0; i<userIds.length; i++)
            {
                String userId = userIds[i];
                if(userId.length() > 0)
                {
                    String attributeId = params.get("user_attr_" + userId);
                    if(attributeId == null)
                    {
                        attributeId = params.get("watcher_attr_" + userId);
                    }
                    if(attributeId == null)
                    {
                        // The specified userid has not been associated to any userAttribute
                        // This happens typically if the specified userId does not exist,
                        // or the userid has no permission to be assigned to this issue.
                        // This can only be an application error (in the velocity templates)
                        // Scarab drops the userID and does not assign a userAttribute
                        // for this user to the issue.
                        
                        scarabR.setAlertMessage("Illegal attempt to assign user with id ["+userId+"] to a new issue. Probably this is a wrong automation setting. Please Check your javascript observers!");
                    }
                    else
                    {
                        userAttributes.put(userId, attributeId);
                    }
                }
                else
                {
                    //The user has selected the "select user..." option, which itself is empty
                }
            }
            returnCode = addUsersToList(user, module, userAttributes, msg);        
            setGUIMessage(returnCode, scarabR, msg);
        }
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doAddmyself(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        ScarabUser user = (ScarabUser)data.getUser();
        
        // clean up first. I may already be in the list
        // [HD]Note: Here i assume, that one user may only show up ONCE
        //     in the list. Apparently it does not make sense to
        //     assign someone AND let the same person observe an issue
        //     at the same time. But OTOH it might be possible, that
        //     other use cases exist, which make it necessary to
        //     have multiple assignments of the same user in the list.
        //     (to be discussed?)
        removeUserFromIssue(user, issue); 

        String attributeId = data.getParameters().get("myself_attribute");
        String userId = user.getUserId().toString();
        Map map = new HashMap();
        map.put(userId, attributeId);
        StringBuffer msg = new StringBuffer();
        int returnCode = addUsersToList(user, scarabR.getCurrentModule(), map, msg);
        setGUIMessage(returnCode, scarabR, msg);       
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doRemovemyself(RunData data, TemplateContext context)
    throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);
        ScarabUser user = (ScarabUser) data.getUser();
        Issue issue = scarabR.getIssue();
        int removeCounter = removeUserFromIssue(user, issue);
        if(removeCounter>0)
        {
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereRemoved);
        }
        else
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
private int addUsersToList(ScarabUser user, Module module, Map userAttributes, StringBuffer msg) throws Exception, TorqueException
    {
        int returnCode;
        Map userMap = user.getAssociatedUsersMap();
        if (userAttributes != null && userAttributes.size() > 0) 
        {
            boolean isUserAttrRemoved = false;
            List removedUserAttrs = null;
            for (Iterator it = userAttributes.keySet().iterator(); it.hasNext(); )
            {
                String userId = (String)it.next();
                List item = new ArrayList();
                String attrId = (String)userAttributes.get(userId);
                Attribute attribute = AttributeManager
                    .getInstance(new Integer(attrId));
                ScarabUser su = ScarabUserManager
                    .getInstance(new Integer(userId));
                item.add(attribute);
                item.add(su);
                List issues = (List)user.getAssignIssuesList();
                for (int j=0; j<issues.size(); j++)
                {
                    Issue issue = (Issue)issues.get(j);
                    Long issueId = issue.getIssueId();
                    Set userList = (Set) userMap.get(issueId);
                    if (userList == null)
                    {
                        userList = new HashSet();
                    }
                    List<Attribute> attributeList = module
                        .getUserAttributes(issue.getIssueType(), true);
                    if (!attributeList.contains(attribute))
                    {
                        if (removedUserAttrs == null)
                        {
                            removedUserAttrs = new ArrayList();
                            removedUserAttrs.add(attribute);
                            msg.append("'").append(attribute.getName())
                                .append("'");
                        }
                        else if (!removedUserAttrs.contains(attribute))
                        {
                            removedUserAttrs.add(attribute);
                            msg.append(", '").append(attribute.getName())
                                .append("'");
                        }
                        isUserAttrRemoved = true;
                    }
                    else
                    {
                        removeUserFromUserSet(su, null, userList); // remove all user entries from set.
                        cleanupMultiAssignEntries(attribute, userList, attributeList);
                        userList.add(item);
                        // userMap.put(issueId, userList);
                        // user.setAssociatedUsersMap(userMap);
                    }
                } 
            }
            if (!isUserAttrRemoved)
            {
                returnCode = USERS_ADDED;
            }
            else 
            {
                returnCode = USERS_REMOVED;
            }
        }
        else
        {
            returnCode = ERR_NO_USERS_SELECTED;
        }
        return returnCode;
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
private void remove(RunData data, TemplateContext context, Long issueId) 
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Set userSet = (Set) user.getAssociatedUsersMap().get(issueId);
        ParameterParser params = data.getParameters();
        String[] selectedUsers =  params.getStrings(SELECTED_USER);
        if (selectedUsers != null && selectedUsers.length > 0) 
        {
            for (int i =0; i<selectedUsers.length; i++)
            {
                List item = new ArrayList(2);
                String selectedUser = selectedUsers[i];
                String userId = selectedUser.substring(1, selectedUser.indexOf('_')-1);
                String attrId = selectedUser.substring(selectedUser.indexOf('_')+1, selectedUser.length());
                Attribute attribute = AttributeManager.getInstance(new Integer(attrId));
                ScarabUser su = ScarabUserManager.getInstance(new Integer(userId));
                Issue issue = IssueManager.getInstance(issueId);
                removeUserFromUserSet(su, attribute, userSet);
            }
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereRemoved);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
private void update(RunData data, TemplateContext context, Long issueId) 
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Set userList = (Set) user.getAssociatedUsersMap().get(issueId);
        ParameterParser params = data.getParameters();
        String[] selectedUsers =  params.getStrings(SELECTED_USER);
        
        if (selectedUsers != null && selectedUsers.length > 0) 
        {
            Issue issue = IssueManager.getInstance(issueId);
            Module module = issue.getModule();
            List<Attribute> attributeList = module.getUserAttributes(issue.getIssueType(), true);
            for (int i =0; i < selectedUsers.length; i++)
            {
                String selectedUser = selectedUsers[i];
                String userId = selectedUser.substring(1, selectedUser.indexOf('_')-1);
                String attrId = selectedUser.substring(selectedUser.indexOf('_')+1, selectedUser.length());
                Attribute attribute = AttributeManager.getInstance(new Integer(attrId));
                ScarabUser su = ScarabUserManager.getInstance(new Integer(userId));

                removeUserFromUserSet(su, attribute, userList);
                
                List newItem = new ArrayList(2);
                String newKey = "asso_user_{" + userId + "}_attr_{" + attrId + "}_issue_{" + issueId + '}';
                String newAttrId = params.get(newKey);
                Attribute newAttribute = AttributeManager.getInstance(new Integer(newAttrId));
                cleanupMultiAssignEntries(newAttribute, userList, attributeList);

                newItem.add(newAttribute);
                newItem.add(su);
                
                userList.add(newItem);
            }
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereModified);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        List issues = null;
        String singleIssueId = data.getParameters().getString("id");
        if (singleIssueId != null)
        {
            Issue issue = scarabR.getIssue(singleIssueId);
            if (issue != null)
            {
                issues = new ArrayList();
                issues.add(issue);
            }
        }
        else
        {
            issues = (List)((ScarabUser)data.getUser()).getAssignIssuesList();
        }

        Map userMap = user.getAssociatedUsersMap();
        ScarabUser assigner = (ScarabUser)data.getUser();
        String reason = data.getParameters().getString("reason", "");
        Attachment attachment = null;
        ActivitySet activitySet = null;
        boolean isUserAttrRemoved = false;
        StringBuffer msg = new StringBuffer();
        List removedUserAttrs = null;

        for (int i=0; i < issues.size(); i++)
        {
            Issue issue = (Issue)issues.get(i);
            Set userList = (Set) userMap.get(issue.getIssueId());
            List oldAssignees = issue.getUserAttributeValues();
            List attributeList = scarabR.getCurrentModule()
                                .getUserAttributes(issue.getIssueType(), true);
            // save attachment with user-provided reason
            if (reason != null && reason.length() > 0)
            {
                attachment = new Attachment();
                attachment.setData(reason);
                attachment.setName("comment");
                attachment.setTextFields(assigner, issue,
                                         Attachment.MODIFICATION__PK);
                attachment.save();
            }

            // loops through users in temporary working list
            for (Iterator iter = userList.iterator(); iter.hasNext();)
            {
                List item = (List)iter.next();
                Attribute newAttr = (Attribute)item.get(0);
                ScarabUser assignee = (ScarabUser)item.get(1);
                Integer assigneeId = assignee.getUserId();
                boolean alreadyAssigned = false;
                if (!attributeList.contains(newAttr))
                {
                    if (removedUserAttrs == null)
                    {
                        removedUserAttrs = new ArrayList();
                        removedUserAttrs.add(newAttr);
                        msg.append("'").append(newAttr.getName()).append("'");
                    }
                    else if (!removedUserAttrs.contains(newAttr))
                    {
                        removedUserAttrs.add(newAttr);
                        msg.append(", '").append(newAttr.getName()).append("'");
                    }
                    isUserAttrRemoved = true;
                }
                else
                {
                    for (int k=0; k < oldAssignees.size(); k++)
                    {
                            AttributeValue oldAttVal = (AttributeValue)
                                                        oldAssignees.get(k);
                        Attribute oldAttr = oldAttVal.getAttribute();
                        // ignore already assigned users
                        if (assigneeId.equals(oldAttVal.getUserId()))
                        {
                            // unless user has different attribute id, then
                            // switch their user attribute
                                if (!newAttr.getAttributeId().equals(
                                                oldAttr.getAttributeId()))
                            {
                                List tmpItem = new ArrayList();
                                tmpItem.add(newAttr);
                                tmpItem.add(assignee);
                                if (!userList.contains(tmpItem))
                                {
                                    alreadyAssigned = true;
                                    activitySet = issue.changeUserAttributeValue(
                                                          activitySet, assignee,
                                                          assigner, oldAttVal,
                                                          newAttr, attachment);
                                }
                            }
                            else
                            {
                                alreadyAssigned = true;
                            }
                        }
                    }
                    // if user was not already assigned, assign them
                    if (!alreadyAssigned)
                    {
                            activitySet = issue.assignUser(activitySet, assignee,
                                        assigner, newAttr, attachment);
                    }
                }
            }

            // loops thru previously assigned users to find ones that
            // have been removed
            for (int m=0; m < oldAssignees.size(); m++)
            {
                boolean userStillAssigned = false;
                AttributeValue oldAttVal = (AttributeValue)oldAssignees.get(m);
                for (Iterator iter = userList.iterator(); iter.hasNext();)
                {
                    List item = (List)iter.next();
                    Attribute attr = (Attribute)item.get(0);
                    ScarabUser su = (ScarabUser)item.get(1);
                    if (su.getUserId().equals(oldAttVal.getUserId())
                        && attr.getAttributeId().equals(oldAttVal.getAttributeId()))
                    {
                         userStillAssigned = true;
                    }
                }
                if (!userStillAssigned)
                {
                    ScarabUser assignee = scarabR.getUser(oldAttVal.getUserId());
                    // delete the user
                    activitySet = issue.deleteUser(activitySet, assignee, 
                                                   assigner, oldAttVal, attachment);
                }
            }
            if (activitySet != null) {
                try
                {
                    NotificationManagerFactory.getInstance()
                            .addActivityNotification(
                                    ActivityType.USER_ATTRIBUTE_CHANGED,
                                    activitySet, issue, user);
                }
                catch(Exception e)
                {
                    L10NMessage l10nMessage = new L10NMessage(EMAIL_ERROR,e);
                    scarabR.setAlertMessage(l10nMessage);
                }
            }
        }
        if (isUserAttrRemoved)
        {
            L10NMessage l10nMsg = new L10NMessage(L10NKeySet.UserAttributeRemoved,
                                                  msg.toString());
            scarabR.setAlertMessage(l10nMsg);
        }
        
        Object alertMessage = scarabR.getAlertMessage();
        if (alertMessage == null || 
            alertMessage.toString().length() == 0)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
        }
    }
              
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doPerform(RunData data, TemplateContext context) 
        throws Exception
    {
        
        Object[] keys =  data.getParameters().getKeys();
        try
        {
            for (int i =0; i<keys.length; i++)
            {
                String key = keys[i].toString();
                if (key.startsWith("eventsubmit_doremove"))
                {
                    String issueId = key.substring(21);
                    remove(data, context, new Long(issueId));
                }
                else if (key.startsWith("eventsubmit_doupdate"))
                {
                    String issueId = key.substring(21);
                    update(data, context, new Long(issueId));
                }
            }
        }
        catch (NumberFormatException nfe) // new Integer(issueId) above could fail
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.BadIntegerConversion);
        }
    }
              
// in java/org/tigris/scarab/actions/Redirect.java
public void doRedirect(RunData data, TemplateContext context)
        throws Exception
    {
        // set the next template
        String nextTemplate = data.getParameters()
            .getString(ScarabConstants.NEXT_TEMPLATE, 
                       ((ScarabUser)data.getUser()).getHomePage());

        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/Redirect.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doRedirect(data, context);
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doAddwatchers(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);
        
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssue();
        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                               issue.getModule()))
        {
            // We'll set the info required by AssignIssue.doAddmyself (the)
            // same that in doEditassignees in this same class.
            data.getParameters().add("id", issue.getUniqueId());
            data.getParameters().add("issue_ids", issue.getUniqueId());
            String watcher = data.getParameters().get("add_watcher");
            data.getParameters().remove("add_user");
            data.getParameters().add("add_user", watcher);

            scarabR.resetAssociatedUsers();
            
            // Lets cross-call the AssignIssue Turbine action!
            AssignIssue assignAction = new AssignIssue();
            assignAction.doAdd(data, context);
            assignAction.doDone(data, context);
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }        
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSubmitattributes(RunData data, TemplateContext context)
        throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }

        final ScarabRequestTool scarabR = getScarabRequestTool(context);
        final ScarabLocalizationTool l10n = getLocalizationTool(context);
        final Issue issue = scarabR.getIssue();
        final Module module = scarabR.getCurrentModule();

        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        final ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        final IntakeTool intake = getIntakeTool(context);
        
        final boolean isReasonRequired = module.isIssueReasonRequired();
        
        // Reason field is required to modify attributes
        final Group reasonGroup = intake.get("Attachment", "attCommentKey" + issue.getQueryKey(), false);
        REASON_SAVE_MODE reasonSaveMode = saveReason(data, isReasonRequired, reasonGroup);

        // Set any other required flags
        final Map selectedOptions = new HashMap();
        final Map conditionallyRequiredFields = new HashMap(); 
        final IssueType issueType = issue.getIssueType();
        final List requiredAttributes = issueType
            .getRequiredAttributes(issue.getModule());
        final LinkedMap modMap = issue.getModuleAttributeValuesMap();
        
        boolean localFieldErrors = false;
        for (Iterator iter = modMap.mapIterator(); iter.hasNext(); ) 
        {
            final AttributeValue aval = (AttributeValue)modMap.get(iter.next());
            final Group group = intake.get("AttributeValue", aval.getQueryKey(), false);
            Field field = null;
            if (group != null) 
            {   
                if (aval instanceof OptionAttribute) 
                {
                    // use optionId instead
                    field = group.get("OptionId");
                    // Will store the selected optionId, for later query against conditions.
                    Object fieldValue = field.getValue();
                    if (null != fieldValue)
                    {
                        selectedOptions.put(fieldValue, field);
                    }
                    
                }
                else if(aval instanceof IntegerAttribute)
                {
                    field = group.get("NumericValue");
                }
                else
                {
                    field = group.get("Value");
                }
                
                Object fieldValue = field.getValue();
                if(fieldValue != null)
                {
                    String fieldValueAsString = fieldValue.toString();
                    if (fieldValueAsString != null && fieldValueAsString.length() > 0) 
                    {
                        boolean exactMatch = true;
                        String pattern = aval.getAttribute().getFormat();
                        String hint = aval.getAttribute().getHint();
                        if (pattern != null && pattern.length() > 0) 
                        {
                            RegexProcessor processor = new RegexProcessor();
                            exactMatch = processor.matches(fieldValueAsString, pattern);
                        }
                        if (!exactMatch) 
                        {
                            if (hint == null || hint.length() == 0)
                                hint = pattern;
                            String[] parameters = new String[] 
                            {
                                    aval.getAttribute().getName(),
                                    fieldValue.toString(), pattern, hint };
                            LocalizationKey key;
                            if (fieldValueAsString.equals(hint)) {
                                key = L10NKeySet.UnprocessedField;
                            } else {
                                key = L10NKeySet.InvalidFieldFormat;
                            }
                            L10NMessage l10nMessage = new L10NMessage(key,
                                    parameters);
                            field.setMessage(l10nMessage.getMessage(l10n));
                            localFieldErrors = true;
                        }
                    }
                }
                
                // check required attributes
                for (int j=requiredAttributes.size()-1; j>=0; j--) 
                {
                    if (aval.getAttribute().getPrimaryKey().equals(
                         ((Attribute)requiredAttributes.get(j)).getPrimaryKey())) 
                    {
                        field.setRequired(true);
                        break;
                    }                    
                }                
            }
            /**
             * If the field has any conditional constraint, will be added to the collection for later query.
             */ 
            final List conditions = aval instanceof UserAttribute
                    ? aval.getAttribute().getConditions()
                    : aval.getRModuleAttribute().getConditions(); 
            if (conditions.size() > 0)
            {
                for (Iterator it = conditions.iterator(); it.hasNext(); )
                {
                    final Condition cond = (Condition)it.next();
                    final Integer id = cond.getOptionId();
                    List fields = (List)conditionallyRequiredFields.get(id);
                    if (fields == null)
                    {
                        fields = new ArrayList();
                    }
                    fields.add( field!=null ? (Object)field : (Object)aval ); // !breaks any generics on this list!
                    conditionallyRequiredFields.put(id, fields);
                }
            }
                
        }

        final boolean attributeValuesValid = submitattributesCheckRequiredAttributes(
                issue, conditionallyRequiredFields, selectedOptions);

        if (intake.isAllValid() && attributeValuesValid && !localFieldErrors) 
        {
            submitattributesPerform(context, user, data, reasonSaveMode);
        } 
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
            // were obviously in editing mode
            data.getParameters().setString("edit_attributes", "true");
            // preserve fullcomments mode
            data.getParameters().setString("fullcomments", data.getParameters().get("fullcomments"));
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
private boolean submitattributesCheckRequiredAttributes(
                final Issue issue,
                final Map conditionallyRequiredFields,
                final Map selectedOptions)
            throws Exception
    {
        boolean attributeValuesValid = true;
        for (Iterator requiredIds = conditionallyRequiredFields.keySet().iterator(); requiredIds.hasNext(); )
        {
            final Integer attributeId= (Integer)requiredIds.next();
            if (selectedOptions.keySet().contains(attributeId))
            {
                final List fields = (List)conditionallyRequiredFields.get(attributeId);
                for (Iterator iter = fields.iterator(); iter.hasNext(); )
                {
                    final Object next = iter.next();
                    if( next instanceof Field )
                    {
                        final Field field = (Field)next;
                        if(null == field.getValue() || field.getValue().toString().length() == 0)
                        {
                            field.setRequired(true);
                            field.setMessage("ConditionallyRequiredAttribute");
                        }
                    }
                    else if(next instanceof UserAttribute)
                    {
                        // An attribute that doesn't exist in intake needs to be 
                        //  added to this issue. 
                        // Currently only UserAttributes exists in this category.
                        final UserAttribute originalAv = (UserAttribute)next;
                        // get attribute value from issue to avoid cached value from intake
                        final UserAttribute freshAv = 
                                (UserAttribute)issue.getAttributeValue(
                                    originalAv.getAttribute());
                        
                        if(freshAv == null || freshAv.getValue() == null)
                        {
                            
                            final AttributeOption option =
                                    AttributeOptionManager.getInstance(attributeId);
                            // Will append the error message to the attribute the user 
                            //  is trying to change instead, since the user attributes
                            // are on a different part/tab on the screen.
                            final Field f = (Field)selectedOptions.get(attributeId);
                            final L10NMessage msg = new L10NMessage(
                                    L10NKeySet.ConditionallyRequiredUserAttribute, 
                                    new Object[]
                                    {
                                        // use original attribute value and it won't be null
                                        originalAv.getAttribute().getName(),
                                        option.getName()
                                    }
                            );
                            f.setMessage(msg.getMessage());
                            attributeValuesValid = false;
                        }
                    }
                }
            }
        }
        return attributeValuesValid;
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
private void submitattributesPerform(
                final TemplateContext context,
                final ScarabUser user,
                RunData runData,
                REASON_SAVE_MODE saveMode)
            throws Exception
    {
        
        // get required tools
        final ScarabRequestTool scarabR = getScarabRequestTool(context);
        final ScarabLocalizationTool l10n = getLocalizationTool(context);
        final Issue issue = scarabR.getIssue();
        final LinkedMap modMap = issue.getModuleAttributeValuesMap();
        final IntakeTool intake = getIntakeTool(context);
        final Group reasonGroup = intake.get("Attachment", "attCommentKey" + issue.getQueryKey(), false);
        
        // start building attribute maps holding the changes
        final HashMap newAttVals = new HashMap();
        // Set the attribute values entered 
        final Iterator iter2 = modMap.mapIterator();
        boolean modifiedAttribute = false;
        
        String assignActiveUser = runData.getParameters().get("add_user");
        if(assignActiveUser != null && assignActiveUser.length() > 0)
        {
            scarabR.resetAssociatedUsers();
            
            // Lets cross-call the AssignIssue Turbine action!
            AssignIssue assignAction = new AssignIssue();
            assignAction.doAdd(runData, context);
            assignAction.doSave(runData, context);
            modifiedAttribute = true;
        }
        
        String assignWatcherUser = runData.getParameters().get("add_watcher");
        if(assignWatcherUser != null && assignWatcherUser.length() > 0)
        {
            doAddwatchers(runData, context);
        }
        
        Attribute myOnHoldDateAttribute = issue.getMyOnHoldExpirationDate();
        Attribute statusAttribute       = issue.getMyStatusAttribute();
        boolean statusChanged = false;
        boolean onHoldDateSet = false;
        boolean isOnHold      = issue.isOnHold();

        while (iter2.hasNext())
        {
            final AttributeValue aval = (AttributeValue)modMap.get(iter2.next());
            final AttributeValue aval2 = AttributeValue.getNewInstance(aval.getAttributeId(), 
                                                  aval.getIssue());
            aval2.setProperties(aval);

            final Group group = intake.get("AttributeValue", aval.getQueryKey(), false);
            String oldValue = "";
            String newValue = "";

            if (group != null) 
            {            
                if (aval instanceof OptionAttribute) 
                {
                    newValue = group.get("OptionId").toString();
                    oldValue = aval.getOptionIdAsString();
                }
                else if (aval instanceof DateAttribute)
                {
                    newValue = DateAttribute.internalDateFormat(
                            group.get("Value").toString(),
                            l10n.get(L10NKeySet.ShortDatePattern));
                    oldValue = aval.getValue();
                }
                else if (aval instanceof IntegerAttribute)
                {
                    newValue = group.get("NumericValue").toString();
                    oldValue = null != aval.getNumericValue() 
                            ? aval.getNumericValue().toString()
                            : "";
                    // mirror the numeric_value into the value field
                    aval2.setValue(newValue);
                }
                else 
                {
                    newValue = group.get("Value").toString();
                    oldValue = aval.getValue();
                }
                // A value has been entered for the attribute.
                // The old value is different from the new, or is unset:
                // Set new value.
                if (newValue.length() > 0
                     && ((oldValue == null) ||
                        (oldValue != null && !oldValue.trim().equals(newValue.trim()))))
                {
                    group.setProperties(aval2);
                    newAttVals.put(aval.getAttributeId(), aval2);
                    modifiedAttribute = true;

                    Attribute att = aval.getAttribute();
                    if(att.equals(statusAttribute))
                    {
                        statusChanged = true;
                    }
                    else if (att.equals(myOnHoldDateAttribute))
                    {
                        onHoldDateSet = true;
                    }
                }
                // The attribute is being undefined. 
                else if (oldValue != null && newValue.length() == 0 && 
                         oldValue.length() != 0)
                {
                    aval2.setValue(null);
                    newAttVals.put(aval.getAttributeId(), aval2);
                    modifiedAttribute = true;
                }
            }
        } 
        
        if (!modifiedAttribute && saveMode!=REASON_SAVE_MODE.NONE)
        {
            scarabR.setAlertMessage(L10NKeySet.MustModifyAttribute);
            runData.getParameters().setString("edit_attributes", "true"); // force edit
            return;
        }
        final Attachment attachment = AttachmentManager.getInstance();
        reasonGroup.setProperties(attachment);

        try
        {
            DateAttribute.convertDateAttributes(newAttVals.values(), 
                    l10n.get(L10NKeySet.ShortDatePattern));                
            final ActivitySet activitySet = issue.setAttributeValues(null, 
                    newAttVals, attachment, user);
            // save reason as a comment as well?
            if(saveMode!=REASON_SAVE_MODE.NONE)
            {
                if( saveMode == REASON_SAVE_MODE.COMMENT )
                {
                    issue.addComment(activitySet, attachment, user);
                }
                else
                {
                    NotificationManagerFactory.getInstance().addActivityNotification(
                                    ActivityType.ATTRIBUTE_CHANGED,
                                    activitySet, issue, user);
                }
                
                if (statusChanged)
                {
                    if(isOnHold)
                    {
                        // ok, the issue was on hold, but now the status has changed.
                        // Hence we must cancel a previous onHoldNotification now.
                        NotificationManagerFactory.getInstance().cancelOnHoldNotification(issue);
                    }
                    else if(issue.isOnHold())
                    {
                        // From the boolean isOnHold==false we deduce that the issue was NOT on hold
                        // prior to this transaction. But from the issue.isOnHold()==true we deduce
                        // that now it IS on hold. Hence the status must have changed during this transaction
                        // from something to onHold.
                        //
                        // And now is the time to create another notification which will be used as wakeup
                        // Notification when the onHoldDate expires. This information must be handled
                        // by the NotificationManager (see the NotificationManager.wakeupOnHoldTimeouts() )
                        NotificationManagerFactory.getInstance().addOnHoldNotification(activitySet, issue, user);
                    }
                }

                
                
            }
            intake.removeAll();
            scarabR.setConfirmMessage(L10NKeySet.ChangesSaved);
        }
        catch (Exception se)
        {
            scarabR.setAlertMessage(l10n.getMessage(se));
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSaveurl (RunData data, TemplateContext context) 
        throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        ScarabUser user = (ScarabUser)data.getUser();

        List urls = issue.getUrls();
        ActivitySet activitySet = null;
        for (int i = 0; i<urls.size(); i++)
        {
            Attachment attachment = (Attachment)urls.get(i);
            if (attachment.getTypeId().equals(Attachment.URL__PK)
                && !attachment.getDeleted())
            {
                Group group = intake.get("Attachment", attachment.getQueryKey(), false);

                Field nameField = group.get("Name"); 
                Field dataField = group.get("Data"); 
                if (dataField.isValid())
                {
                    dataField.setRequired(true);
                }
                
                if (intake.isAllValid())
                {
                    // store the new and old data
                    String oldDescription = attachment.getName();
                    String oldURL = new String(attachment.getData());
                    String newDescription = nameField.toString();
                    String newURL = dataField.toString();

                    if (!oldDescription.equals(newDescription))
                    {
                        group.setProperties(attachment);
                        attachment.save();
                        activitySet = issue
                            .doChangeUrlDescription(activitySet, user, 
                                                    attachment, oldDescription);
                        scarabR.setConfirmMessage(L10NKeySet.UrlSaved);
                    }
                    if (!oldURL.equals(newURL))
                    {
                        group.setProperties(attachment);
                        attachment.save();
                        activitySet = issue
                            .doChangeUrlUrl(activitySet, user, 
                                            attachment, oldURL);
                        scarabR.setConfirmMessage(L10NKeySet.UrlSaved);
                    }
                }
                else
                {
                     scarabR.setAlertMessage(ERROR_MESSAGE);
                }
            }
        }

        // if there is a new URL, add it
        Group newGroup = intake.get("Attachment", "urlKey", false);
        if (newGroup != null)
        { 
            Field dataField = newGroup.get("Data");
            String dataFieldString = dataField.toString();
            if (dataFieldString != null && dataFieldString.trim().length() > 0)
            {
                if (intake.isAllValid())
                {
                    // create the new attachment
                    Attachment attachment = AttachmentManager.getInstance();
                    // set the form data to the attachment object
                    newGroup.setProperties(attachment);
                    activitySet = issue.addUrl(attachment, user);

                    // remove the group
                    intake.remove(newGroup);
                    scarabR.setConfirmMessage(L10NKeySet.UrlSaved);
                    NotificationManagerFactory.getInstance()
                            .addActivityNotification(
                                    ActivityType.URL_ADDED, activitySet,
                                    issue,
                                    user);
                }
                else
                {
                     scarabR.setAlertMessage(ERROR_MESSAGE);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doEditcommentpage(RunData data, TemplateContext context)
         throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        if (!user.hasPermission(ScarabSecurity.ISSUE__COMMENT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }
        data.getParameters().add("edit_comments", "true");
        data.getParameters().add("fullcomments", data.getParameters().get("fullcomments"));
        return;
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doEditattributespage(RunData data, TemplateContext context)
         throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }
        data.getParameters().setString("edit_attributes", "true");
        data.getParameters().setString("fullcomments", data.getParameters().get("fullcomments"));
        return;
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSubmitcomment (RunData data, TemplateContext context) 
         throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__COMMENT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        Group group = intake.get("Attachment", "commentKey", false);
        if (group != null) 
        {
            Attachment attachment = AttachmentManager.getInstance();
            try
            {
                group.setProperties(attachment);
            }
            catch (Exception e)
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
                return;
            }
            
            try
            {
                issue.addComment(attachment, (ScarabUser)data.getUser());
            }
            catch(Exception e)
            {
                String l10nMessage = l10n.getMessage(e);
                scarabR.setAlertMessage(l10nMessage);
                return;
            }
            scarabR.setConfirmMessage(L10NKeySet.CommentSaved);
            intake.remove(group);
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSubmitfile (RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__ATTACH, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        Group group = intake.get("Attachment", "fileKey" + issue.getQueryKey(), false);
        Field nameField = group.get("Name"); 
        // set some required fields
        if (nameField.isValid())
        {
            nameField.setRequired(true);
        }
        // validate intake
        if (intake.isAllValid() && group != null)
        {
            // adding a file is a special process
            addFileAttachment(issue, group, (Attachment) null, scarabR, data,
                              intake);
            ActivitySet activitySet = issue.doSaveFileAttachments(user);
            if (activitySet != null)
            {
                scarabR.setConfirmMessage(L10NKeySet.FileSaved);
                NotificationManagerFactory.getInstance()
                        .addActivityNotification(
                                ActivityType.ATTACHMENT_CREATED,
                                activitySet, issue, user);
                
            }
            else
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
static void addFileAttachment(Issue issue, Group group,
                                  Attachment attachment,
                                  ScarabRequestTool scarabR, RunData data,
                                  IntakeTool intake)
        throws Exception
    {
        if (group != null)
        {
            Field nameField = group.get("Name");
            Field fileField = group.get("File");
            nameField.setRequired(true);
            fileField.setRequired(true);
            Field mimeAField = group.get("MimeTypeA");
            Field mimeBField = group.get("MimeTypeB");
            String mimeA = mimeAField.toString();
            String mimeB = mimeBField.toString();
            String mimeType = null;
            if (mimeB != null && mimeB.trim().length() > 0)
            {
                mimeType = mimeB;
            }
            else if ("autodetect".equals(mimeA) && fileField.isValid())
            {
                try 
                {
                    String filename = 
                        ((FileItem)fileField.getValue()).getName();
                    String contentType = 
                        ComponentLocator.getMimeTypeService().getContentType(filename, null);
                    if (contentType == null) 
                    {
                        // could not match extension.
                        mimeAField
                            .setMessage("intake_CouldNotDetermineMimeType");
                    }
                    else 
                    {
                        mimeType = contentType;
                    }
                }
                catch (Exception e)
                {
                    // we do not want any exception thrown here to affect
                    // the user experience, it is just considered a 
                    // non-detectable file type.  But still the exception is
                    // not expected, so log it.
                    mimeAField.setMessage("intake_CouldNotDetermineMimeType");
                    Log.get().info(
                        "Could not determine mimetype of uploaded file.", e);
                }                
            }
            else
            {
                mimeAField.setRequired(true);
                mimeType = mimeA;
            }
            if (group.isAllValid()) 
            {
                if (attachment == null)
                {
                    attachment = AttachmentManager.getInstance();
                }
                group.setProperties(attachment);
                attachment.setMimeType(mimeType);
                issue.addFile(attachment, (ScarabUser)data.getUser());
                // remove the group so that the form data doesn't show up again
                intake.remove(group);
            }
            else
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
            }
        }
        else
        {
            scarabR.setAlertMessage(L10NKeySet.CouldNotLocateAttachmentGroup);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doEditcomment (RunData data, TemplateContext context)
        throws Exception
    {                          
        if (isCollision(data, context)) 
        {
            return;
        }
        
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        if (!user.hasPermission(ScarabSecurity.ISSUE__COMMENT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        ActivitySet activitySet = null;
        for (int i=0; i<keys.length; i++)
        {
            String key = (String) keys[i];
            if (key.startsWith("edit_comment_"))
            {
                String attachmentId = key.substring(13);
                String newComment = params.getString(key,"");
                Attachment attachment = AttachmentManager
                    .getInstance(new NumberKey(attachmentId), false);
                try
                {
                    activitySet = issue.doEditComment(activitySet, newComment, 
                                                      attachment, user);
                }
                catch (ScarabException se)
                {
                    scarabR.setAlertMessage(l10n.getMessage(se));
                }
            }
        }
        if (activitySet != null)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);  
        }
        else
        {
            scarabR.setInfoMessage(L10NKeySet.NoCommentsChanged);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doDeleteurl (RunData data, TemplateContext context)
        throws Exception
    {                          
        if (isCollision(data, context)) 
        {
            return;
        }
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        ActivitySet activitySet = null;
        for (int i=0; i < keys.length; i++)
        {
            String key = (String) keys[i];
            if (key.startsWith("url_delete_"))
            {
                String attachmentId = key.substring(11);
                Attachment attachment = AttachmentManager
                    .getInstance(new NumberKey(attachmentId), false);
                activitySet = issue.doDeleteUrl(activitySet, attachment, user);
            }
        }
        if (activitySet != null)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_DELETED, activitySet, issue, user);
        }
        else
        {
            scarabR.setInfoMessage(L10NKeySet.NoUrlsChanged);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doDeletefile (RunData data, TemplateContext context)
        throws Exception
    {      
        if (isCollision(data, context)) 
        {
            return;
        }
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        ActivitySet activitySet = null;

        boolean allFilesDeleted = true;

        boolean deletePhysically = Turbine.getConfiguration()
        .getBoolean("scarab.attachment.remove.permanent",false);

        for (int i = 0; i < keys.length; i++)
        {
            String key = (String) keys[i];
            if (key.startsWith("file_delete_"))
            {
                String attachmentId = key.substring(12);
                Attachment attachment = AttachmentManager.getInstance(
                new NumberKey(attachmentId), false);
                MutableBoolean physicallyDeleted = new MutableBoolean(false);
                activitySet = issue.doRemoveAttachment(activitySet, physicallyDeleted, attachment,  user);
                //set deleted to false if at least for one of the
                //deleted attachmnents the file was not removed from
                //disk. 
                if (deletePhysically && !physicallyDeleted.booleanValue())
                {
                    allFilesDeleted = false;
                }
            }
        }

        if (activitySet != null)
        {
            if (allFilesDeleted)
            {
                scarabR.setConfirmMessage(DEFAULT_MSG);
            }
            else
            {
                scarabR.setAlertMessage(L10NKeySet.FilesPartiallyDeleted);
            }
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.ATTACHMENT_REMOVED, activitySet,
                    issue, user);
        }
        else
        {
            scarabR.setInfoMessage(L10NKeySet.NoFilesChanged);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSavedependencychanges(RunData data, TemplateContext context)
        throws Exception
    {
        saveDependencyChanges(data, context, false);
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSavenewdependencies(RunData data, TemplateContext context)
        throws Exception
    {
        saveNewDependencies(data, context, false);
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
private void saveDependencyChanges(RunData data, TemplateContext context, 
                                       boolean doDelete)
        throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        String modifyDepTo = data.getParameters().get("modifyDepTo");
        boolean changesMade = false;

        DependType newDependType = null;
        if(modifyDepTo == null || modifyDepTo.equals(""))
        {
            // no dependType set -> error
        }
        else if (modifyDepTo.equals("remove"))
        {
            changesMade = doRemoveSelectedDependencies(issue, intake, scarabR, 
                          context, l10n, user);
        }
        else
        {
            /* If modifyDepTo equals "-1" we want the current issue to become
             * a prerequisite for the other issue.
             */
            boolean setAsPrerequisite = false;
            if(modifyDepTo.equals("-1"))
            {
                modifyDepTo = modifyDepTo.substring(1);
                setAsPrerequisite = true;
            }

            newDependType = DependTypeManager.getInstanceById(modifyDepTo);
            changesMade = doUpdatedependencies(issue, intake, scarabR, 
                          context, user, newDependType, setAsPrerequisite);
        }        

        if (!changesMade)
        {
            scarabR.setInfoMessage(NO_CHANGES_MADE);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
private void saveNewDependencies(RunData data, TemplateContext context, 
                                       boolean doDelete)
        throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        Group group = intake.get("Depend","newDep"+issue.getQueryKey(),false);

        boolean depAdded = doAdddependency(issue, intake, group, scarabR,
                                           context, l10n, user);
        if (!depAdded)
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
            scarabR.setInfoMessage(NO_CHANGES_MADE);
        }
        else
        {
            intake.remove(group);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
private boolean doAdddependency(Issue issue, IntakeTool intake,
                                 Group group, ScarabRequestTool scarabR,
                                 TemplateContext context,
                                 ScarabLocalizationTool l10n,
                                 ScarabUser user)
        throws Exception
    {
        // Check that dependency type entered is valid
        Field type = group.get("TypeId");
        Integer typeAsInteger = null;
        try
        {
            typeAsInteger = (Integer)type.getValue();
        }
        catch (Exception e)
        {
            type.setMessage(l10n.get(L10NKeySet.SelectRelation));
            return false;
        }
        boolean needRoleSwitch = false;
        if(typeAsInteger.intValue() < 1)
        {
            typeAsInteger = new Integer( -1 * typeAsInteger.intValue());
            needRoleSwitch = true;
        }

        type.setRequired(true);
        // Check that child ID entered is valid
        Field childId = group.get("ObserverUniqueId");
        childId.setRequired(true);
        if (!type.isValid() && childId.isValid())
        {
            type.setMessage(l10n.get(L10NKeySet.EnterValidDependencyType));
            return false;
        }
        else if (type.isValid() && !childId.isValid())
        {
            childId.setMessage(l10n.get(L10NKeySet.EnterValidIssueId));
            return false;
        }
        String childIdStr = childId.toString();
        // we need to struggle here because if there is no
        // issue id, we just want to return because the person
        // on the page could just be updating existing deps
        // and in this case, the issue id might be empty.
        if (childIdStr != null)
        {
            childIdStr.trim();
        }
        if (childIdStr == null || childIdStr.length() == 0)
        {
            return true;
        }
        // Check that child ID entered corresponds to a valid issue
        // The id might not have the prefix appended so use the current
        // module prefix as the thing to try.
        Issue childIssue = null;
        Module currentModule = scarabR.getCurrentModule();
        try
        {
            childIssue = IssueManager
                .getIssueById(childIdStr, currentModule.getCode());
        }
        catch(Exception e)
        {
            // Ignore this
        }
        if (childIssue == null || childIssue.getDeleted())
        {
            childId.setMessage(l10n.get(L10NKeySet.EnterValidIssueId));
            return false;
        }
        

        
        // Make sure issue is not being marked as dependant on itself.
        else if (childIssue.equals(issue))
        {
            childId.setMessage(l10n.get(L10NKeySet.CannotAddSelfDependency));
            return false;
        }
        if (intake.isAllValid())
        {
            Depend depend = DependManager.getInstance();
            depend.setDefaultModule(currentModule);
            group.setProperties(depend);
            depend.setTypeId(typeAsInteger);
            ActivitySet activitySet = null;
            try
            {
                if (needRoleSwitch)
                {
                    depend.exchangeRoles();
                    activitySet = issue
                    .doAddDependency(activitySet, depend, childIssue, user);
                }
                else{
                    activitySet = childIssue
                    .doAddDependency(activitySet, depend, issue, user);
                }

            }
            catch (ScarabException se)
            {
                childId.setMessage(se.getL10nMessage().getMessage(l10n));
                return false;
            }
            catch (Exception e)
            {
                log().debug("Delete error: ", e);
                return false;
            }

            scarabR.setConfirmMessage(DEFAULT_MSG);
            if (activitySet != null)
            {
                // FIXME: I think that we are sending too many emails here
                NotificationManagerFactory.getInstance()
                        .addActivityNotification(
                                ActivityType.DEPENDENCY_CREATED,
                                activitySet, childIssue, user);
                NotificationManagerFactory.getInstance()
                        .addActivityNotification(
                                ActivityType.DEPENDENCY_CREATED,
                                activitySet, issue, user);
            }
            return true;
        }
        else
        {
            return false;
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
private boolean doUpdatedependencies(Issue issue, IntakeTool intake, 
                                       ScarabRequestTool scarabR,
                                       TemplateContext context,
                                       ScarabUser user,
                                       DependType newDependType,
                                       boolean setAsPrerequisite)
        throws Exception
    {

        ActivitySet activitySet = null;
        List dependencies = issue.getAllDependencies();

        for (int i=0; i < dependencies.size(); i++)
        {
            Issue workingIssue = issue;
            Depend oldDepend = (Depend)dependencies.get(i);
            DependType oldDependType = oldDepend.getDependType();
            String intakeKey = oldDepend.getObserverId().toString();
            boolean thisIsPrerequisite = true;
            Group group = intake.get("Depend", intakeKey, false);
            if (group == null)
            {
                thisIsPrerequisite = false;
                intakeKey = oldDepend.getObservedId().toString();
                group = intake.get("Depend", intakeKey, false);
                if (group == null)
                {
                    // there is nothing to do here.
                    continue;
                }
                workingIssue = IssueManager.getInstance(oldDepend.getObservedId(), false);
            }

            Depend newDepend = DependManager.getInstance();
            // copy oldDepend properties to newDepend
            newDepend.setProperties(oldDepend);


            // set properties on the object
            group.setProperties(newDepend);

            boolean isSelected = newDepend.getSelected();
            boolean dependTypeModified = !oldDependType.equals(newDependType);
            boolean needRoleSwitch = newDependType.getName().equals("blocking") && setAsPrerequisite!=thisIsPrerequisite;
            if (isSelected && (dependTypeModified || needRoleSwitch ))
            {
                // need to do this because newDepend could have the deleted
                // flag set to true if someone selected it as well as 
                // clicked the save changes button. this is why we have the 
                // doDeleted flag as well...issue.doChange will only do the
                // change if the deleted flag is false...so force it...
                newDepend.setDeleted(false);
                newDepend.setDependType(newDependType);

                if(needRoleSwitch)
                {
                    newDepend.exchangeRoles();
                }
                
                 // make the changes
                  activitySet = 
                  workingIssue.doChangeDependencyType(activitySet, oldDepend,
                                                      newDepend, user);
            }
            intake.remove(group);
        }

        // something changed...
        if (activitySet != null)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.DEPENDENCY_CHANGED,
                    activitySet, issue, user);
            return true;
        }
        else // nothing changed
        {
            return false;
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
private boolean doRemoveSelectedDependencies(Issue issue, IntakeTool intake, 
                                       ScarabRequestTool scarabR,
                                       TemplateContext context,
                                       ScarabLocalizationTool l10n,
                                       ScarabUser user)
        throws Exception
    {

        ActivitySet activitySet = null;
        List dependencies = issue.getAllDependencies();

        for (int i=0; i < dependencies.size(); i++)
        {
            Depend oldDepend = (Depend)dependencies.get(i);
            
            // Assume, issue takes the role "observer"
            String intakeKey = oldDepend.getObserverId().toString();
            Group group = intake.get("Depend", intakeKey, false);
            Issue workingIssue = issue;

            if (group == null)
            {
                // Maybe issue takes the role "observed"
                intakeKey = oldDepend.getObservedId().toString();
                group = intake.get("Depend", intakeKey, false);
                if(group == null)
                {
                    // there is nothing to do here.
                    continue;
                }
                workingIssue = oldDepend.getIssueRelatedByObservedId();
            }

            group.setProperties(oldDepend);
            if (oldDepend.getSelected())
            {
                try
                {
                    activitySet = 
                        workingIssue.doDeleteDependency(activitySet, oldDepend, user);
                }
                catch (ScarabException se)
                {
                    // it will error out if they attempt to delete
                    // a dep via a child dep.
                    String l10nKey = se.getMessage();
                    scarabR.setAlertMessage(l10n.get(l10nKey));
                }
                catch (Exception e)
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    log().debug("Delete error: ", e);
                }
            }
            intake.remove(group);
        }

        // something changed...
        if (activitySet != null)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.DEPENDENCY_CHANGED,
                    activitySet, issue, user);
            
            return true;
        }
        else // nothing changed
        {
            return false;
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doEditassignees(RunData data, TemplateContext context)
         throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        intake.removeAll();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                               issue.getModule()))
        {
            data.getParameters().add("id", issue.getUniqueId());
            data.getParameters().add("issue_ids", issue.getUniqueId());
            scarabR.resetAssociatedUsers();
            setTarget(data, "AssignIssue.vm");
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doMove(RunData data, TemplateContext context)
         throws Exception
    {
        boolean collisionOccurred = isCollision(data, context);
        context.put("collisionDetectedOnMoveAttempt", collisionOccurred ? Boolean.TRUE : Boolean.FALSE);
        if (collisionOccurred)
        {
            // Report the collision to the user.
            return;
        }
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module module = scarabR.getCurrentModule();
        List moveToModules =((ScarabUser)data.getUser()).getCopyToModules(module, "move");
        if (moveToModules.size() > 0)
        {
            ParameterParser pp = data.getParameters();
            pp.setString("mv_0rb", "move");
            ((IntakeTool)context.get("intake")).get("MoveIssue")
                .getDefault().get("Action").init(pp);
            String[] issueIds = pp.getStrings("issue_ids");
            String currentIssueId = getScarabRequestTool(context).getIssue().getUniqueId();
            if (!ScarabUtil.contains(issueIds, currentIssueId))
            {
                pp.add("issue_ids", currentIssueId);
            }
            setTarget(data, "MoveIssue.vm");
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            setTarget(data, "ViewIssue.vm");
        }
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doCopy(RunData data, TemplateContext context)
         throws Exception
    {
        boolean collisionOccurred = isCollision(data, context);
        context.put("collisionDetectedOnMoveAttempt", collisionOccurred ? Boolean.TRUE : Boolean.FALSE);
        if (collisionOccurred)
        {
            // Report the collision to the user.
            return;
        }
        ParameterParser pp = data.getParameters();
        pp.setString("mv_0rb", "copy");
        ((IntakeTool)context.get("intake")).get("MoveIssue")
            .getDefault().get("Action").init(pp);
        String[] issueIds = pp.getStrings("issue_ids");
        String currentIssueId = getScarabRequestTool(context).getIssue().getUniqueId();
        if (!ScarabUtil.contains(issueIds, currentIssueId))
        {
            pp.add("issue_ids", currentIssueId);
        }
        setTarget(data, "MoveIssue.vm");            
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSetissueview(RunData data, TemplateContext context)
         throws Exception
    {
        String tab = data.getParameters().getString("tab", 
                                          ScarabConstants.ISSUE_VIEW_ALL);
        data.getUser().setTemp(ScarabConstants.TAB_KEY, tab); 
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doAddmyself(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);
        
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssue();
        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                               issue.getModule()))
        {
            // We'll set the info required by AssignIssue.doAddmyself (the)
            // same that in doEditassignees in this same class.
            data.getParameters().add("id", issue.getUniqueId());
            data.getParameters().add("issue_ids", issue.getUniqueId());

            scarabR.resetAssociatedUsers();
            
            // Lets cross-call the AssignIssue Turbine action!
            AssignIssue assignAction = new AssignIssue();
            assignAction.doAddmyself(data, context);
            assignAction.doDone(data, context);
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }        
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doDeleteissue(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssue();
        if (user != null && issue != null)
        {
           issue.deleteIssue(user);
        }
        L10NMessage msg = new L10NMessage(L10NKeySet.IssueDeleted, issue.getUniqueId());
        scarabR.setInfoMessage(msg);
    }
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doRemovemyself(RunData data, TemplateContext context)
    throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);

        ScarabUser user = (ScarabUser) data.getUser();
        Issue issue = scarabR.getIssue();
        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, issue.getModule()))
        {
            // We'll set the info required by AssignIssue.doRemovemyself (the)
            // same that in doEditassignees in this same class.
            data.getParameters().add("id", issue.getUniqueId());
            data.getParameters().add("issue_ids", issue.getUniqueId());

            scarabR.resetAssociatedUsers();

            // Lets cross-call the AssignIssue Turbine action!
            AssignIssue assignAction = new AssignIssue();
            assignAction.doRemovemyself(data, context);
            assignAction.doDone(data, context);
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }
    }
              
// in java/org/tigris/scarab/actions/ChangePassword.java
public void doChangepassword(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String template = getCurrentTemplate(data, null);
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid())
        {
            Object user = data
                .getUser()
                .getTemp(ScarabConstants.SESSION_REGISTER);
            Group register = null;
            if (user != null && user instanceof ScarabUser)
            {
                register = intake.get("Register",
                                 ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                register = intake.get("Register",
                                 IntakeTool.DEFAULT_KEY, false);
            }
            
            String username = data.getParameters().getString("username");
            String oldPassword = register.get("OldPassword").toString();
            String password = register.get("Password").toString();
            String passwordConfirm = register.get("PasswordConfirm").toString();
            
            if (oldPassword.equals(password))
            {
                scarabR.setInfoMessage(L10NKeySet.PasswordSame);
                setTarget(data, template);
            } 
            else if (password.equals(passwordConfirm))
            {
                try
                {
                    ScarabUser confirmedUser = ScarabUserManager.getInstance(username);

                    // first we need to save the user out
                    confirmedUser.setPasswordExpire();
                    confirmedUser.setHasLoggedIn(Boolean.FALSE);
                    data.setUser(confirmedUser);
                    data.save();

                    // then change the password of that user
                    TurbineSecurity.changePassword(confirmedUser, 
                        oldPassword, password);

                    scarabR.setConfirmMessage(L10NKeySet.PasswordChanged);
                    
                    // Remove NEXT_TEMPLATE, so we will start again from home after login
                    data.getParameters().remove(ScarabConstants.NEXT_TEMPLATE);
                    setTarget(data, "Login.vm");
                }
                catch (PasswordMismatchException pme)
                {
                    scarabR.setAlertMessage(l10n.getMessage(pme));
                    setTarget(data, template);
                }
            }
            else /* !password.equals(passwordConfirm) */
            {
                scarabR.setAlertMessage(L10NKeySet.PasswordsDoNotMatch);
                setTarget(data, template);
            }
        }
        else
        {
            scarabR.setAlertMessage("Failed to process form input.");
            setTarget(data, template);
        }
    }
              
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);

        // Add user's new selection of attributes
        ParameterParser params = data.getParameters();
        String[] ids = params.getStrings("attid");
        String[] orders = params.getStrings("attorder");
        MITList mitlist = ((ScarabUser)data.getUser()).getCurrentMITList();
        boolean isSingleModuleIssueType = mitlist.isSingleModuleIssueType();

        if (ids != null)
        {
	        List attributes = new ArrayList(ids.length);
	        final Map orderMap = new HashMap();            
	        for (int i =0; i<ids.length; i++)
	        {
                RModuleUserAttribute pref = RModuleUserAttributeManager.getInstance();
                pref.setUserId(((ScarabUser)data.getUser()).getUserId());
	            if (!orders[i].equals("hidden")) 
	            {
                    Integer order = new Integer(orders[i]);
                    try
                    {
    	                Attribute attribute = AttributeManager
    	                    .getInstance(new Integer(ids[i]));
                        if (isSingleModuleIssueType)
                        {
                            //String value = mitlist.getModule().getRModuleAttribute(attribute, mitlist.getIssueType()).getDisplayValue();
                            pref.setAttribute(attribute);
                            pref.setIssueType(mitlist.getIssueType());
                        }
                        else
                        {
                            pref.setMITList(mitlist);
                            pref.setAttribute(attribute);
                        }
                        orderMap.put(pref.getAttributeId(), order);
                    }
                    catch (NumberFormatException nfe)
                    {
                        pref.setInternalAttribute(ids[i]);
                        orderMap.put(pref.getInternalAttribute(), order);
                    }
                    attributes.add(pref);
	            }
	        }
	
	        if (attributes.isEmpty())
	        {
	            scarabR.setAlertMessage(L10NKeySet.MustSelectAtLeastOneAttribute);
	            setTarget(data, data.getParameters()
	                            .getString(ScarabConstants.TEMPLATE, 
	                                       "ConfigureIssueList.vm"));
	            return;
	        }
	        else if (((ScarabUser)data.getUser()).getCurrentMITList() == null) 
	        {
	            scarabR.setAlertMessage(L10NKeySet.NoIssueTypeList);
	            return;            
	        }
	        else
	        {
	            Comparator c = new Comparator()
	                {
	                    public int compare(Object o1, Object o2)
	                    {
                            RModuleUserAttribute a1 = (RModuleUserAttribute)o1;
                            RModuleUserAttribute a2 = (RModuleUserAttribute)o2;
	                        int order1, order2;
                            if (a1.isInternal())
                            {
                                order1 = ((Integer)orderMap.get(a1.getInternalAttribute())).intValue();
                            }
                            else
                            {
                                order1 = ((Integer)orderMap.get(a1.getAttributeId())).intValue();
                            }
                            if (a2.isInternal())
                            {
                                order2 = ((Integer)orderMap.get(a2.getInternalAttribute())).intValue();
                            }
                            else
                            {
                                order2 = ((Integer)orderMap.get(a2.getAttributeId())).intValue();
                            }
                            
                            int result = order1 - order2;
	                        if (result == 0) 
	                        {
	                            result = a1.getName().compareTo(a2.getName());
	                        }
	                        return result;
	                    }
	                };
	            Collections.sort(attributes, c);
                context.put("attributepreferences", attributes);
                scarabR.setConfirmMessage(DEFAULT_MSG);
	            try
	            {
	                ((ScarabUser)data.getUser()).updateIssueListAttributes(attributes);
//  	                scarabR.setConfirmMessage(DEFAULT_MSG);
	            }
	            catch (TurbineSecurityException tse)
	            {
	                scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
	            }
	        }
        }
        
        scarabR.clearCachedQueryResult();
        
        doCancel(data,context);
    }
              
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
public void doUsedefaults(RunData data, TemplateContext context) 
        throws Exception
    {
        data.getParameters().add("usedefaults", "true"); 
    }
              
// in java/org/tigris/scarab/actions/Login.java
public void doLogin(RunData data, TemplateContext context)
        throws Exception
    {
        data.setACL(null);
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid() && checkUser(data, context))
        {
            ScarabUser user = (ScarabUser)data.getUser();
            List userModules = user.getModules();
            if (userModules != null)
            {
                Module uniqueModule = null;
                if (userModules.size() == 2)
                {
                    Module module1 = (Module)userModules.get(0);
                    Module module2 = (Module)userModules.get(1);
                    if (module1.isGlobalModule())
                    {
                        uniqueModule = module2;
                    }
                    else if (module2.isGlobalModule())
                    {
                        uniqueModule = module1;
                    }
                }
                else if (userModules.size() == 1)
                {
                    uniqueModule = (Module)userModules.get(0);
                    if (uniqueModule.isGlobalModule())
                    {
                        uniqueModule = null;
                    }
                }

                if (uniqueModule != null )
                {
                    getScarabRequestTool(context).setCurrentModule(uniqueModule);
                    data.getParameters().remove(ScarabConstants.CURRENT_MODULE);
                    data.getParameters().add(ScarabConstants.CURRENT_MODULE,
                                             uniqueModule.getQueryKey());

                    if ("SelectModule.vm".equals(data.getParameters()
                            .getString(ScarabConstants.NEXT_TEMPLATE, "SelectModule.vm"))
                        && user.hasPermission(ScarabSecurity.ISSUE__ENTER, uniqueModule )) 
                    {
                        data.getParameters().remove(ScarabConstants.NEXT_TEMPLATE);
                        
                        Query defaultQuery = QueryPeer.getDefaultQuery(uniqueModule, user.getUserId());
                        ParameterParser pp = data.getParameters();
                        if(defaultQuery != null)
                        {
                            String qkey = defaultQuery.getQueryKey();
                            pp.add(ScarabConstants.NEXT_TEMPLATE, "IssueList.vm");
                            //pp.add("queryId", qkey);
                            //pp.add("query", qkey);
                            //data.setAction("Search");
                            pp.setString("eventSubmit_doSelectquery", "foo");
                            pp.setString("go",qkey);
                            Search action = new Search();
                            action.doSelectquery(data, context);
                            
                            MITList mitList = defaultQuery.getMITList();
                            user.setCurrentMITList(mitList);
                            String mitListId = Long.toString(mitList.getListId());
                            pp.setString(ScarabConstants.CURRENT_MITLIST_ID, mitListId);
                        }
                        else
                        {
                            pp.add(ScarabConstants.NEXT_TEMPLATE, "home,EnterNew.vm");
                        }
                    }
                }
            }
            String template = data.getParameters()
                .getString(ScarabConstants.NEXT_TEMPLATE, 
                           "SelectModule.vm");
            setTarget(data, template);
        }
    }
              
// in java/org/tigris/scarab/actions/Login.java
public boolean checkUser(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);

        Group login = intake.get("Login", IntakeTool.DEFAULT_KEY);
        String username = login.get("Username").toString();
        String password = login.get("Password").toString();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        return authentifyWithCredentials(data, scarabR, username, password);
    }
              
// in java/org/tigris/scarab/actions/Login.java
public static boolean authentifyWithCredentials(RunData data, ScarabRequestTool scarabR, String username, String password) throws Exception
    {
        
        ScarabUser user = authenticateUser(data, scarabR, username, password);
        if(user == null)
        {
            // Could not authenticate the user
            return false;
        }

        try
        {
            if (user.getConfirmed().equals(ScarabUser.DELETED))
            {
                setAlertMessage(scarabR,L10NKeySet.UserIsDeleted);
                Log.get().error("Deleted user attempting to log in");
                failAction(data, "Login.vm");
                return false;
            }
            // check the CONFIRM_VALUE
            if (!user.isConfirmed())
            {
                user = (ScarabUser) TurbineSecurity.getUserInstance();
                setUser(scarabR, user);
                setAlertMessage(scarabR,L10NKeySet.UserIsNotConfirmed);

                failAction(data, "Confirm.vm");
                return false;
            }


            // store the user object
            data.setUser(user);
            // mark the user as being logged in
            user.setHasLoggedIn(Boolean.TRUE);
            // set the last_login date in the database
            user.updateLastLogin();

            // check if the password is expired
            boolean userPasswordExpired = user.isPasswordExpired();
            if (userPasswordExpired)
            {
                user = (ScarabUser) TurbineSecurity.getUserInstance();
                setUser(scarabR, user);
                setAlertMessage(scarabR,L10NKeySet.YourPasswordHasExpired);

                setTarget(data, "ChangePassword.vm");
                //change next screen to allow password reset.
                data.save();
                return false;
            }

            // update the password expire
            user.setPasswordExpire();
            // this only happens if the user is valid
            // otherwise, we will get a valueBound in the User
            // object when we don't want to because the username is
            // not set yet.
                       
            // save the User object into the session
            data.save();

        }
        catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionTurbineGeneric,e);
            setAlertMessage(scarabR,msg);
            failAction(data, "Login.vm");
            return false;
        }
        return true;
    }
              
// in java/org/tigris/scarab/actions/Login.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doLogin(data, context);
    }
              
// in java/org/tigris/scarab/actions/Logout.java
public void doLogout(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        boolean bWasLoggedIn = data.getUserFromSession() != null && !((ScarabUser)data.getUserFromSession()).isUserAnonymous();
        scarabR.setCurrentModule(null);
        data.getParameters().remove(ScarabConstants.CURRENT_MODULE);
        data.setACL(null);
        Login.anonymousLogin(data);
        context.put("modulelink", new ModuleSwitchingLink(data));
        
        if(data.getUser()!=null)
        {
            data.save();
            if (bWasLoggedIn)
            {
                scarabR.setConfirmMessage(L10NKeySet.YouHaveBeenLoggedOut);
            }
        }
        setTarget(data, "Login.vm");
    }
              
// in java/org/tigris/scarab/actions/Logout.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doLogout(data, context);
    }
              
// in java/org/tigris/scarab/actions/MoveIssue.java
public void doValidate(RunData data, TemplateContext context)
        throws Exception
    {
        boolean collisionOccurred = isCollision(data, context);
        context.put("collisionDetectedOnMoveAttempt",
                    collisionOccurred ? Boolean.TRUE : Boolean.FALSE);
        if (collisionOccurred)
        {
            // Report the collision to the user.
            doCancel(data, context);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        if (!intake.isAllValid())
        {
            return;
        }

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String[] issueIds = data.getParameters().getStrings("issue_ids");
        List issues = new ArrayList();
        Issue issue = null;
        if (issueIds == null || issueIds.length == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectIssueToMove);
            return;
        }
        else
        {
            for (int i= 0; i<issueIds.length; i++)
            {
                issues.add(scarabR.getIssue(issueIds[i]));
            }
            issue = (Issue)issues.get(0);
        }

        Module oldModule = issue.getModule();
        Group moveIssue = intake.get("MoveIssue",
                          IntakeTool.DEFAULT_KEY, false);
        String[] modIssueTypes =
            data.getParameters().getStrings("mod_issuetype");
        String modIssueType = null;
        if (modIssueTypes != null)
        {
            for (int i=0; i<modIssueTypes.length; i++) 
            {
                String testOption = modIssueTypes[i];
                if (testOption != null && testOption.length() > 0) 
                {
                    if (modIssueType == null) 
                    {
                        modIssueType = testOption;
                    }
                    else 
                    {
                        scarabR.setAlertMessage(L10NKeySet.OnlySelectOneDestination);
                        return;
                    }
                }
            }

        }

        if (modIssueType == null)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectModuleAndIssueType);
            return;
        }
        
        Integer newModuleId = null;
        Integer newIssueTypeId = null;
        Module newModule = null;        
        try
        {
            newModuleId = new Integer(modIssueType.
                      substring(0, modIssueType.indexOf('_')));
            newIssueTypeId = new Integer(modIssueType.
                      substring(modIssueType.indexOf('_')+1, modIssueType.length()));
            newModule = ModuleManager
                               .getInstance(newModuleId);

        }
        catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectModuleAndIssueType);
            return;
        }
          
        String selectAction = moveIssue.get("Action").toString();
        ScarabUser user = (ScarabUser)data.getUser();
        boolean changeModule = !newModuleId.equals(oldModule.getModuleId());
        boolean changeIssueType = !newIssueTypeId
            .equals(issue.getIssueType().getIssueTypeId());

        // Check permissions
        // Must have ISSUE_ENTER in new module
        // If moving to a new module, must have ISSUE_MOVE in old module
        // If moving to a new issue type, must have ISSUE_EDIT in old module
        if (!user.hasPermission(ScarabSecurity.ISSUE__ENTER, newModule))
        {
            data.setMessage(l10n.get(NO_PERMISSION_MESSAGE));
            return;
        }
        if ("move".equals(selectAction))
        {
            if (changeModule && 
                !user.hasPermission(ScarabSecurity.ISSUE__MOVE, oldModule) || 
                (changeIssueType && 
                !user.hasPermission(ScarabSecurity.ISSUE__EDIT, oldModule)))
            {
                data.setMessage(l10n.get(NO_PERMISSION_MESSAGE));
                return;
            }
        }
        // Do not allow user to move issue if source and destination
        // Module and issue type are the same
        if ("move".equals(selectAction) && !changeModule && !changeIssueType)
        {
            scarabR.setAlertMessage(L10NKeySet.CannotMoveToSameModule);
            return;
        }
       
        context.put("newModuleId", newModuleId.toString());
        context.put("newIssueTypeId", newIssueTypeId.toString());
        String nextTemplate = getNextTemplate(data);
        setTarget(data, nextTemplate);
    }
              
// in java/org/tigris/scarab/actions/MoveIssue.java
public void doSaveissue(RunData data, TemplateContext context)
        throws Exception
    {
    	//Clear cache for stability reasons, to avoid missing, cached values
    	IssueManager.getMethodResult().clear();
    	
        boolean collisionOccurred = isCollision(data, context);
        context.put("collisionDetectedOnMoveAttempt", collisionOccurred ? Boolean.TRUE : Boolean.FALSE);
        if (collisionOccurred)
        {
            // Report the collision to the user.
            setTarget(data, "ViewIssue.vm");
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        if (!intake.isAllValid())
        {
            return;
        }

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String[] issueIds = data.getParameters().getStrings("issue_ids");
        List issues = new ArrayList();
        Issue issue = null;
        if (issueIds == null || issueIds.length == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectIssueToMove);
            return;
        }
        else
        {
            for (int i= 0; i<issueIds.length; i++)
            {
                issues.add(scarabR.getIssue(issueIds[i]));
            }
            issue = (Issue)issues.get(0);
        }

        Module oldModule = issue.getModule();
        IssueType oldIssueType = issue.getIssueType();
        Group moveIssue = intake.get("MoveIssue",
                          IntakeTool.DEFAULT_KEY, false);
        Integer newModuleId = ((Integer) moveIssue.get("ModuleId").
            getValue());
        Integer newIssueTypeId = ((Integer) moveIssue.get("IssueTypeId").
            getValue());
        Module newModule = ModuleManager
               .getInstance(newModuleId);
        IssueType newIssueType = IssueTypeManager
               .getInstance(newIssueTypeId);
        String selectAction = moveIssue.get("Action").toString();
        ScarabUser user = (ScarabUser)data.getUser();

        ActivityType activityType = null;
        if (selectAction.equals("move"))
            activityType = ActivityType.ISSUE_MOVED;
        else
            activityType = ActivityType.ISSUE_COPIED;
        
        // Get selected non-matching attributes to save in comment
        List commentAttrs = new ArrayList();
        List commentUserValues = new ArrayList();
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        for (int i=0; i<keys.length; i++)
        {
            String key = (String) keys[i];
            if (key.startsWith("comment_attr_ids_"))
            {
                commentAttrs.add(scarabR 
                        .getAttribute(new Integer(key.substring(17))));
            }
            if (key.startsWith("comment_user_attval_"))
            {
                Long valueId = new Long(key.substring(20));
                commentUserValues.add(AttributeValuePeer.retrieveByPK(valueId));
            }
        }
        String reason = params.getString("reason");
        if (reason == null || reason.trim().length() == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.ReasonRequired);
            return;
        }

        Issue newIssue = null;
        for (int i=0; i<issues.size(); i++)
        {
            issue = (Issue)issues.get(i);
            // Do the copy/move
            try
            {
            	if("move".equals(selectAction)){
            		 newIssue = issue.move(newModule, newIssueType, user,
                             reason, commentAttrs, commentUserValues);
            	}
            	else if("copy".equals(selectAction)){
            		 newIssue = issue.copy(newModule, newIssueType, user,
                             reason, commentAttrs, commentUserValues);
            	}
               
            }
            catch (Exception e)
            {
                L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
                scarabR.setAlertMessage(l10nMessage);
                Log.get().warn("Exception during issue copy/move", e);
                return;
            }

            // Send notification for the target issue/module
            NotificationManagerFactory.getInstance().addActivityNotification(
                    activityType,
                    newIssue.getLastActivitySet(), issue, null, null, user);

            // If it's moved, should also notify users associated in the old
            // location because the issue is dissapearing from there.
            if (activityType == ActivityType.ISSUE_MOVED)
            {
                NotificationManagerFactory
                        .getInstance()
                        .addActivityNotification(
                                activityType,
                                issue.getLastActivitySet(), issue, null,
                                null, user);
            }
        }

        // Redirect to moved or copied issue
        if (issues.size() == 1)
        {
            data.getParameters().remove("id");
            data.getParameters().add("id", newIssue.getUniqueId().toString());
            setTarget(data, "ViewIssue.vm");
        }
        else
        {
            setTarget(data, "IssueList.vm");
        }

        scarabR.setConfirmMessage(DEFAULT_MSG);
    }
              
// in java/org/tigris/scarab/actions/MoveIssue.java
public void doBacktoone(RunData data, TemplateContext context) throws Exception
    {
        setTarget(data, data.getParameters()
            .getString(ScarabConstants.CANCEL_TEMPLATE, "MoveIssue.vm"));
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public ScarabUser getGeneratedBy() 
        throws Exception
    {
        if (generatedBy == null) 
        {
            if (torqueReport.getUserId() != null) 
            {
                generatedBy = 
                    ScarabUserManager.getInstance(torqueReport.getUserId());
            }
        }
        
        return generatedBy;
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setGeneratedBy(ScarabUser  v)
        throws Exception
    {
        this.generatedBy = v;
        torqueReport.setUserId(v.getUserId());
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setMITList(MITList mitList)
        throws Exception
    {
        if (mitList == null) 
        {
            reportDefn.setModuleIssueTypes(null);
            setModule(null);
            setIssueType(null);
        }
        else 
        {
            boolean isOk = true;
            // need to check that the changes are compatible with the currently
            // selected criteria
            for (Iterator roai = reportDefn
                .retrieveAllReportOptionAttributes().iterator(); 
                 roai.hasNext() && isOk;) 
            {
                isOk = mitList.isCommon( AttributeOptionManager.getInstance( 
                    ((ReportOptionAttribute)roai.next())
                    .getOptionId()));
            }
            for (Iterator ruai = reportDefn
                .retrieveAllReportUserAttributes().iterator(); 
                 ruai.hasNext() && isOk;) 
            {
                isOk = mitList.isCommon( AttributeManager.getInstance( 
                    ((ReportUserAttribute)ruai.next())
                    .getAttributeId()));
            }
            
            if (!isOk) 
            {
                throw new IncompatibleMITListException(L10NKeySet.ExceptionIncompatibleMITListChanges); //EXCEPTION
            }
            
            reportDefn.setModuleIssueTypes(null);
            setModule(null);
            setIssueType(null);

            for (Iterator i = mitList.getExpandedMITListItems().iterator(); i.hasNext();) 
            {
                MITListItem item = (MITListItem)i.next();
                ModuleIssueType mit = new ModuleIssueType();
                mit.setModuleId(item.getModuleId());
                mit.setIssueTypeId(item.getIssueTypeId());
                reportDefn.addModuleIssueType(mit);
            }
            if (mitList.isSingleModule()) 
            {
                torqueReport.setModule(mitList.getModule());
            }
            if (mitList.isSingleIssueType()) 
            {
                torqueReport.setIssueType(mitList.getIssueType());
            }
        }
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public boolean removeStaleDefinitions()
        throws Exception
    {
        boolean reportModified = false;
        MITList mitList = getMITList();
        List axes = reportDefn.getReportAxisList();
        if (axes != null) 
        {
            for (Iterator i = axes.iterator(); i.hasNext();) 
            {
                ReportAxis axis = (ReportAxis)i.next();
                List headings = axis.getReportHeadings();
                if (headings != null) 
                {
                    for (Iterator j = headings.iterator(); j.hasNext();) 
                    {
                        ReportHeading heading = (ReportHeading)j.next();
                        reportModified |= removeStaleOptions(
                            heading.getReportOptionAttributes(), mitList);
                        reportModified |= removeStaleUserAttributes(heading
                            .getReportUserAttributes(), mitList);
                        List groups = heading.getReportGroups();
                        if (groups != null && !groups.isEmpty()) 
                        {
                            for (Iterator n = groups.iterator(); n.hasNext();) 
                            {
                                ReportGroup group = (ReportGroup)n.next();
                                reportModified |= removeStaleOptions(
                                    group.getReportOptionAttributes(), mitList );
                                reportModified |= removeStaleUserAttributes( 
                                    group.getReportUserAttributes(), mitList );
                            }
                        }
                    }
                }
            }
        }
        return reportModified;
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
private boolean removeStaleOptions(List options, MITList mitList)
        throws Exception
    {
        boolean anyRemoved = false;
        if (options != null && !options.isEmpty()) 
        {
            for (Iterator n = options.iterator(); n.hasNext();)
            {
                ReportOptionAttribute rao = 
                    (ReportOptionAttribute)n.next();
                AttributeOption ao = AttributeOptionManager
                    .getInstance(rao.getOptionId());
                if (!mitList.isCommon(ao, false)) 
                {
                    n.remove();
                    anyRemoved = true;
                }
                else if (!mitList.isCommon(ao.getAttribute(), false)) 
                {
                    n.remove();
                    anyRemoved = true;
                }
            }
        }
        return anyRemoved;
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
private boolean removeStaleUserAttributes(List attributes, MITList mitList)
        throws Exception
    {
        boolean anyRemoved = false;
        if (attributes != null && !attributes.isEmpty()) 
        {
            for (Iterator n = attributes.iterator(); n.hasNext();)
            {
                ReportUserAttribute rua = 
                    (ReportUserAttribute)n.next();
                Attribute attr = AttributeManager
                    .getInstance(rua.getAttributeId());
                if (!mitList.isCommon(attr, false)) 
                {
                    n.remove();
                    anyRemoved = true;
                }
            }
        }
        return anyRemoved;
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public ReportTableModel getCachedModel(ScarabUser searcher)
        throws Exception
    {        
        ReportTableModel model=(ReportTableModel) ReportManager.getMethodResult().get(this,GET_CACHED_MODEL,searcher);

        if(model==null){
            generatedDate=new Date();
            model=new ReportTableModel(this, getGeneratedDate(), searcher);
        }

        ReportManager.getMethodResult().put(model,this,GET_CACHED_MODEL,searcher);

        return model;
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public ReportTableModel getModel(ScarabUser searcher) throws Exception
    {
        return new ReportTableModel(this, getGeneratedDate(), searcher);
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void save() 
        throws Exception
    {
        torqueReport.setQueryString(getQueryString());
        torqueReport.save();
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void populate(String v)
        throws Exception
    {
        if (v == null)
        {
            reportDefn = new ReportDefinition();
        }
        else
        {
            BeanReader reader = new BeanReader();
            reader.registerBeanClass(ReportDefinition.class);
            reportDefn = (ReportDefinition) 
                reader.parse(new StringReader(v));

            Logger log = Log.get();
            if (log.isDebugEnabled())
            {
                log.debug("Created a new report using:\n " + v + 
                          "; and it resulted in:\n " + 
                          reportDefn.toXmlString());
            }
        }
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
String getQueryString()
        throws Exception
    {
        return reportDefn.toXmlString();
    }
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void populateSearch(IssueSearch search, ReportHeading heading)
        throws Exception
    {
        List reportOptions = heading.getReportOptionAttributes();
        if (reportOptions == null || reportOptions.isEmpty()) 
        {
            List groups = heading.getReportGroups();
            if (groups != null && !groups.isEmpty()) 
            {
                reportOptions = new ArrayList();
                for (Iterator i = groups.iterator(); i.hasNext();) 
                {
                    ReportGroup group = (ReportGroup)i.next();
                    List tmpOptions = group.getReportOptionAttributes();
                    if (tmpOptions != null && !tmpOptions.isEmpty()) 
                    {
                        for (Iterator j = tmpOptions.iterator(); j.hasNext();) 
                        {
                            reportOptions.add(j.next());
                        }
                    }
                }
            }
        }

        if (reportOptions != null && !reportOptions.isEmpty()) 
        {
            Map commonAttributeMap = new HashMap(reportOptions.size());
            for (Iterator i = reportOptions.iterator(); i.hasNext();) 
            {
                ReportOptionAttribute roa = (ReportOptionAttribute)i.next();
                Integer optionId = roa.getOptionId();
                AttributeOption ao = 
                    AttributeOptionManager.getInstance(optionId);

                Integer attId = AttributeOptionManager.getInstance(optionId).getAttributeId();
                Attribute attr = AttributeManager.getInstance(attId); 

                AttributeValue prevAV = 
                    (AttributeValue)commonAttributeMap.get(attId);

                if(prevAV!=null) 
                {
                	AttributeValue av = AttributeValue
                    .getNewInstance(attr, prevAV.getIssue());
                    av.setAttributeOption(ao);
                    prevAV.setChainedValue(av);
                }
                else 
                {
                	AttributeValue av = search.addAttributeValue(attr, ao);
                    commonAttributeMap.put(attId, av);
                }
            }
        }
    }
              
// in java/org/tigris/scarab/reports/ReportTableModel.java
public Object getValueAt(int row, int column)
        throws Exception
    {
        if (row < 0 || row >= getRowCount())
        {
            throw new IndexOutOfBoundsException("Row index was " + row); //EXCEPTION
        }
        
        if (column < 0 || column >= getColumnCount()) 
        {
            throw new IndexOutOfBoundsException("Column index was " + column); //EXCEPTION
        }

        Object contents = ReportManager.getMethodResult().get(this,GET_VALUE_AT,new Integer(row),new Integer(column));

        if(contents==null){
        
            //could use a categories list to make this simpler
            if (columnHeadings != null && columnHeadings.size() == 1 && 
                    ((ReportHeading)columnHeadings.get(0)).get(0) instanceof ReportDate) 
            {
                Date date = ((ReportDate) ((ReportHeading) columnHeadings.get(0))
                             .get(column)).dateValue();
                if (date.getTime() <= System.currentTimeMillis())
                {
                    contents = new Integer(getIssueCount(getRowDataArray(row),
                                                         date));
                }
                else
                {
                    // Dates in the future are not applicable to reporting.
                    contents = "";
                }
            }
            else if (rowHeadings != null && rowHeadings.size() == 1 && 
                     ((ReportHeading)rowHeadings.get(0)).get(0) instanceof ReportDate)
            {
                Date date = ((ReportDate)((ReportHeading)rowHeadings.get(0))
                             .get(row)).dateValue();
                if (date.getTime() <= System.currentTimeMillis())
                {
                   contents = new Integer(getIssueCount(
                        getColumnDataArray(column), date));
                }
                else
                {
                   // Dates in the future are not applicable to reporting.
                   contents = "";
                }
            }
            else if (columnHeadings != null && columnHeadings.size() == 1 && 
                    ((ReportHeading)columnHeadings.get(0)).get(0) instanceof ReportDateRange) 
            {
            	Date minDate =((ReportDateRange)((ReportHeading)columnHeadings.get(0))
                        .get(column)).getMinDate(searcher.getLocale());
            	
            	Date maxDate = ((ReportDateRange)((ReportHeading)columnHeadings.get(0))
                        .get(column)).getMaxDate(searcher.getLocale());
            	
            	contents = new Integer(getIssueCountRange(
                        getRowDataArray(row), minDate, maxDate));
            	
            }
            else if (rowHeadings != null && rowHeadings.size() == 1 && 
                     ((ReportHeading)rowHeadings.get(0)).get(0) instanceof ReportDateRange)
            {
            	Date minDate = ((ReportDateRange)((ReportHeading)rowHeadings.get(0))
                        .get(row)).getMinDate(searcher.getLocale());
            	
            	Date maxDate = ((ReportDateRange)((ReportHeading)rowHeadings.get(0))
                        .get(row)).getMaxDate(searcher.getLocale());
            	
            	contents = new Integer(getIssueCountRange(
                        getColumnDataArray(column), minDate, maxDate));
            }
            else
            {
                contents = new Integer(getIssueCount(
                    getRowDataArray(row), getColumnDataArray(column), date)); 
            }

            ReportManager.getMethodResult().put(contents,this,GET_VALUE_AT,new Integer(row),new Integer(column));
        }

        return contents;
    }
              
// in java/org/tigris/scarab/reports/ReportTableModel.java
private int getIssueCount(Object[] rowData, Object[] columnData, Date date)
        throws Exception
    {
        Criteria crit = new Criteria();
        // select count(issue_id) from activity a1 a2 a3, activitySet t1 t2 t3
        crit.addSelectColumn("count(DISTINCT a0." + ACT_ISSUE_ID + ')');
        int rowLength = rowData.length;
        for (int i=0; i<rowLength; i++) 
        {
            addOptionOrGroup(i, rowData[i], null, date, crit);
            
        }
        for (int i=0; i<columnData.length; i++) 
        {
            addOptionOrGroup(i+rowLength, columnData[i], null, date, crit);
        }
        return getCountAndCleanUp(crit);
    }
              
// in java/org/tigris/scarab/reports/ReportTableModel.java
public int getIssueCount(Object[] dataArray, Date date)
        throws Exception
    {
        Criteria crit = new Criteria();
        crit.addSelectColumn("count(DISTINCT a0." + ACT_ISSUE_ID + ')');
        for (int i=0; i<dataArray.length; i++) 
        {
            addOptionOrGroup(i, dataArray[i], null, date, crit);
        }
        return getCountAndCleanUp(crit);
    }
              
// in java/org/tigris/scarab/reports/ReportTableModel.java
public int getIssueCountRange(Object[] dataArray, Date minDate, Date maxDate)
    throws Exception
    {
    	Criteria crit = new Criteria();
    	crit.addSelectColumn("count(DISTINCT a0." + ACT_ISSUE_ID + ')');
    	for (int i=0; i<dataArray.length; i++) 
    	{
    		addOptionOrGroup(i, dataArray[i], minDate, maxDate, crit);
    	}
    	return getCountAndCleanUp(crit);
    }
              
// in java/org/tigris/scarab/reports/ReportTableModel.java
private int getCountAndCleanUp(Criteria crit)
        throws Exception
    {
        int result = 0;
        if (isSearchAllowed) 
        {
            if (isXMITSearch())
            {
                mitList.addToCriteria(crit);
            }
            else 
            {
                crit.add(IssuePeer.MODULE_ID, moduleId);
                crit.add(IssuePeer.TYPE_ID, issueTypeId);
            }
            crit.add(IssuePeer.DELETED, false);
            crit.add(IssuePeer.MOVED, false);
            result = ((Record)ActivityPeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
        }
        
        return result;
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static String handleRequest(Context context, String template)
        throws Exception
    {
        return getService().handleRequest(context, template);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public String handleRequest(Context context, String template,
                                String charset, String encoding)
        throws Exception
    {
        return getService().handleRequest(context, template, charset,
                                          encoding);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static void handleRequest(Context context, String template,
                                     OutputStream out)
        throws Exception
    {
        getService().handleRequest(context, template, out);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static void handleRequest(Context context, String template,
                                     OutputStream out, String charset,
                                     String encoding)
        throws Exception
    {
        getService().handleRequest(context, template, out, charset, encoding);
    }
              
// in java/org/tigris/scarab/services/DatabaseInitializer.java
private void initdb(Locale defaultLocale)
        throws Exception
    {
        String[][] methodNames = getInputData();        
        Class[] stringSig = {String.class};
        Class[] critSig = {Criteria.class};

        for (int m=0; m<methodNames.length; m++) 
        {
            String[] row = methodNames[m];
            String omClassName = "org.tigris.scarab.om." + row[1];
            Class peerClass = Class.forName(omClassName + "Peer");
            Object peerObject = peerClass.newInstance();

            Method doSelect = peerClass.getMethod("doSelect", critSig);
            Object[] critArg = {new Criteria()};
            List omlist = (List)doSelect.invoke(peerObject, critArg);
            if (!omlist.isEmpty()) 
            {
                Class omClass = Class.forName(omClassName);
                int nbrBeanMethods = row.length - 2;
                Method[] getters = new Method[nbrBeanMethods];
                Method[] setters = new Method[nbrBeanMethods];
                for (int n=2; n<row.length; n++) 
                {
                    getters[n-2] = omClass.getMethod("get"+row[n], (java.lang.Class)null);
                    setters[n-2] = omClass.getMethod("set"+row[n], stringSig);
                }
                Method save = omClass.getMethod("save", (java.lang.Class)null);

                Iterator i = omlist.iterator();
                while (i.hasNext()) 
                {
                    Object om = i.next();
                    for (int n=0; n<getters.length; n++) 
                    {
                        Log.get().debug("Converting " + row[1] + '.' + 
                                        getters[n].getName());
                        String key = (String)getters[n].invoke(om, (java.lang.Object)null);
                        String value = null;

                        // Oracle returns null on empty field.
                        if (key != null)
                        {
                            try 
                            {
                                value = Localization.getString(row[0], 
                                                               defaultLocale,
                                                               key);
                            }
                            catch (MissingResourceException e)
                            {
                                Log.get().debug("Missing database initialization "
                                                + "resource: " + e.getMessage());
                            } 
                        }
                        if (value != null) 
                        {
                            Object[] arg = {value};
                            setters[n].invoke(om, arg);
                        }
                    }
                    save.invoke(om, (java.lang.Object)null);
                } 
            }
        }
    }
              
// in java/org/tigris/scarab/services/DatabaseInitializer.java
private void checkNewHttpParameters()
        throws Exception
    {
        String oldDomain = GlobalParameterManager
            .getString(ScarabConstants.HTTP_DOMAIN);
        String oldScheme = GlobalParameterManager
            .getString(ScarabConstants.HTTP_SCHEME);
        String oldScriptName = GlobalParameterManager
            .getString(ScarabConstants.HTTP_SCRIPT_NAME);
        String oldPort = GlobalParameterManager
            .getString(ScarabConstants.HTTP_PORT);

        if (oldDomain.equals(""))
        {
            // installations with post-b15 but pre-b16 may have module
            // specific values.  
            Criteria crit = new Criteria();
            crit.add(GlobalParameterPeer.NAME, MODULE_DOMAIN);
            List parameters = GlobalParameterPeer.doSelect(crit);
            if (!parameters.isEmpty()) 
            {
                oldDomain = ((GlobalParameter)parameters.get(0)).getValue();
            }

            crit = new Criteria();
            crit.add(GlobalParameterPeer.NAME, MODULE_SCHEME);
            parameters = GlobalParameterPeer.doSelect(crit);
            if (!parameters.isEmpty()) 
            {
                oldScheme = ((GlobalParameter)parameters.get(0)).getValue();
            }

            crit = new Criteria();
            crit.add(GlobalParameterPeer.NAME, MODULE_SCRIPT_NAME);
            parameters = GlobalParameterPeer.doSelect(crit);
            if (!parameters.isEmpty()) 
            {
                oldScriptName = 
                    ((GlobalParameter)parameters.get(0)).getValue();
            }

            crit = new Criteria();
            crit.add(GlobalParameterPeer.NAME, MODULE_PORT);
            parameters = GlobalParameterPeer.doSelect(crit);
            if (!parameters.isEmpty()) 
            {
                oldPort = ((GlobalParameter)parameters.get(0)).getValue();
            }
        }

        String newValue = Turbine.getConfiguration()
            .getString(ScarabConstants.HTTP_DOMAIN);
        if (newValue != null && newValue.trim().length() != 0
            && !newValue.equals(oldDomain)) 
        {
            GlobalParameterManager
                .setString(ScarabConstants.HTTP_DOMAIN, newValue);
            fixIssueIdCounters(oldDomain, newValue);
        }

        newValue = Turbine.getConfiguration()
            .getString(ScarabConstants.HTTP_SCHEME);
        if (newValue != null && newValue.trim().length() != 0
            && !newValue.equals(oldScheme)) 
        {
            GlobalParameterManager
                .setString(ScarabConstants.HTTP_SCHEME, newValue);
        }

        newValue = Turbine.getConfiguration()
            .getString(ScarabConstants.HTTP_SCRIPT_NAME);
        if (newValue != null && newValue.trim().length() != 0
            && !newValue.equals(oldScriptName)) 
        {
            GlobalParameterManager
                .setString(ScarabConstants.HTTP_SCRIPT_NAME, newValue);
        }

        newValue = Turbine.getConfiguration()
            .getString(ScarabConstants.HTTP_PORT);
        if (newValue != null && newValue.trim().length() != 0
            && !newValue.equals(oldPort)) 
        {
            GlobalParameterManager
                .setString(ScarabConstants.HTTP_PORT, newValue);
        }
    }
              
// in java/org/tigris/scarab/services/DatabaseInitializer.java
private void fixIssueIdCounters(String oldDomain, String newDomain)
        throws Exception
    {
        String sql = 
            "select NEXT_ID from ID_TABLE where TABLE_NAME='ID_TABLE'";
        Connection con = null;
        try 
        {
            con = Torque.getConnection();
            Statement s = con.createStatement();
            ResultSet rs = s.executeQuery(sql);
            int maxId = 0;
            if (rs.next()) 
            {
                maxId = rs.getInt(1);
            }
            s.close();

            for (int id = 1000; id <= maxId; id++) 
            {
                sql = "select TABLE_NAME from ID_TABLE where ID_TABLE_ID=" 
                    + id;
                s = con.createStatement();
                rs = s.executeQuery(sql);
                if (rs.next()) 
                {
                    String oldKey = rs.getString(1);
                    s.close();
                    int hyphenPos = oldKey.indexOf('-');
                    String newKey = null;
                    if ( (oldDomain == null || oldDomain.length() == 0)
                         && hyphenPos <= 0) 
                    {
                        newKey = newDomain + '-' + oldKey;
                    }
                    else 
                    {
                        String prefix = oldKey.substring(0, hyphenPos);
                        String code = oldKey.substring(hyphenPos+1);
                        if (prefix.equals(oldDomain)) 
                        {
                            newKey = newDomain + '-' + code;
                        }
                    }
                    
                    if (newKey != null) 
                    {
                        sql = "update ID_TABLE set TABLE_NAME='" + newKey +
                            "' where ID_TABLE_ID=" + id;
                        s = con.createStatement();
                        s.executeUpdate(sql);
                        s.close();
                    }
                }
            }
        }
        finally
        {
            if (con != null) 
            {
                con.close();
            }
        }
    }
              
// in java/org/tigris/scarab/services/TorqueService.java
protected void loadOM()
        throws Exception
    {
        ActivityManager.getInstance();
        ActivitySetManager.getInstance();
        ActivitySetTypeManager.getInstance();
        AttachmentManager.getInstance();
        AttachmentTypeManager.getInstance();
        AttributeClassManager.getInstance();
        AttributeGroupManager.getInstance();
        AttributeManager.getInstance();
        AttributeOptionManager.getInstance();
        AttributeTypeManager.getInstance();
        // AttributeValue class is abstract
        AttributeValueManager.getManager();
        Class.forName("org.tigris.scarab.om.AttributeValue");
        DependManager.getInstance();
        DependTypeManager.getInstance();
        FrequencyManager.getInstance();
        GlobalParameterManager.getInstance();
        // Issue class does not have public no-arg ctor
        IssueManager.getManager();
        Class.forName("org.tigris.scarab.om.Issue");
        IssueTemplateInfoManager.getInstance();
        IssueTypeManager.getInstance();
        IssueVoteManager.getInstance();
        MITListItemManager.getInstance();
        MITListManager.getInstance();
        ModificationManager.getInstance();
        ModuleManager.getInstance();
        OptionRelationshipManager.getInstance();
        PendingGroupUserRoleManager.getInstance();
        QueryManager.getInstance();
        RAttributeAttributeGroupManager.getInstance();
        ReportManager.getInstance();
        RIssueTypeAttributeManager.getInstance();
        RIssueTypeOptionManager.getInstance();
        RModuleAttributeManager.getInstance();
        RModuleIssueTypeManager.getInstance();
        RModuleOptionManager.getInstance();
        RModuleUserAttributeManager.getInstance();
        // ROptionOption class does not have public no-arg ctor
        ROptionOptionManager.getManager();
        Class.forName("org.tigris.scarab.om.ROptionOption");
        RQueryUserManager.getInstance();
        ScarabUserManager.getInstance();
        ScopeManager.getInstance();
        UserPreferenceManager.getInstance();
        UserVoteManager.getInstance();
    }
              
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }

        JCSCache = JCS.getInstance(SCARAB_CACHE_REGION);

        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }

    }
              
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
        maps = new WeakHashMap();
        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
        
    }
              
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
public void synchUser(SearchResult sr) throws Exception {
		Attributes attributes = sr.getAttributes();
		
		String uid = (String) attributes.get(loginAttribute).get(0);
		logger.info("uid : " + uid);

        boolean isNewUser = false;
		ScarabUser user = ScarabUserManager.getInstance(uid);
		if (user == null) {
			user = ScarabUserManager.getInstance();
			isNewUser = true;
		}

		user.setEmail(getAttributeValue(attributes.get("mail"), "Unknown"));
		user.setLastName(getAttributeValue(attributes.get("sn"), "Unknown"));
		user.setFirstName(getAttributeValue(attributes.get("givenName"),
				"Unknown"));

		if(isNewUser)
		{
            user.setName(uid);
            // Generate random password to avoid security hole.
            // This will be reset when the user logs in the first time
            user.setPassword(PasswordGenerator.generate());
            user.createNewUser();
            ScarabUserImpl.confirmUser(uid);
		} 
		else
		{    
		    user.save();
		}
	}
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
protected boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        return ScarabModulePeer.checkExists(group);
    }
              
// in java/org/tigris/scarab/util/ScarabLink.java
public ScarabLink getIssueIdLink(Issue issue)
        throws Exception
    {
        this.addPathInfo("id", issue.getUniqueId());
        return this;
    }
              
// in java/org/tigris/scarab/util/ScarabLink.java
public ScarabLink getIssueIdAbsoluteLink(Issue issue)
        throws Exception
    {
        ScarabLink link = getIssueIdLink(issue);
        link.setRelative(false).setEncodeUrl(false);
        return link;
    }
              
// in java/org/tigris/scarab/util/ScarabUtil.java
public static String linkifyText(String input, ScarabLink link, Module module)
        throws Exception
    {
        StringBuffer sb = new StringBuffer(input.length() * 2);
        List result = IssueIdParser.tokenizeText(module, input);
        for (Iterator itr = result.iterator(); itr.hasNext();)
        {
            Object tmp = itr.next();
            if (tmp instanceof String)
            {
                sb.append(tmp);
            }
            else
            {
                final List tmpList = (List)tmp;
                final String id = (String)tmpList.get(1);
                final Issue issue = IssueManager.getIssueById(id);
                
                if(issue != null){
                	 final String defaultText = issue.getDefaultText();
                     final String attributes = "alt=\"" + defaultText + "\" title=\"" + defaultText + "\"";

                     link.addPathInfo("id", id);
                     link.addPathInfo("tab", "1");
                     link.setLabel((String)tmpList.get(0));
                     final String bar = link.setAttributeText(attributes).toString();
                     sb.append(bar);
                }
                else{
                	//write token back, no valid issue found for linking
                	sb.append((String)tmpList.get(0));	
                }
               
            }
        }
        return sb.toString();
    }
              
// in java/org/tigris/scarab/util/ScarabUtil.java
public static StringValueParser parseURL(String url) throws Exception
    {
        StringValueParser parser = new StringValueParser();
        parser.setCharacterEncoding("UTF-8");
        parser.parse(url, '&', '=', true);
        return parser;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearchFactory.java
public IssueSearch getInstance(Issue issue, ScarabUser searcher)
        throws Exception
    {
        return new IssueSearch(issue, searcher);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearchFactory.java
public IssueSearch
        getInstance(Module module, IssueType issueType, ScarabUser searcher)
        throws Exception
    {
        return new IssueSearch(module, issueType, searcher);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearchFactory.java
public IssueSearch getInstance(MITList mitList, ScarabUser searcher)
        throws Exception
    {
        return new IssueSearch(mitList, searcher);
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public List executeQuery(TextQuery textQuery) 
        throws Exception
    {
        String queryText = textQuery.toString();
        
        Query luceneQuery;
        try
        {
           luceneQuery = new QueryParser("", analyzer).parse(queryText);
        }
        catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }

        List issueIds = new ArrayList();
        IndexSearcher is = new IndexSearcher(indexDir); 
        try
        {
            Hits hits = is.search(luceneQuery);
            
            for(Iterator hi = hits.iterator(); hi.hasNext();)
            {
                Hit h = (Hit)hi.next();
                issueIds.add( Long.valueOf(h.get(ISSUE_ID)));
            }
        }
        finally
        {
            is.close();
        }        
        return issueIds;
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void index(Issue issue)
    throws Exception
    {
        Document doc = document(issue);
        synchronized(this)
        {
            update(doc);
            optimize(false);
            flush();
        }
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private void update(Document doc)
    throws Exception
    {    
        writer.updateDocument(new Term( ISSUE_ID, doc.get(ISSUE_ID) ), doc); 
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private void rebuild(RebuildMonitor rebuildMonitor)
        throws Exception
    {        
        Criteria crit = new Criteria()
            .add(IssuePeer.DELETED, false);
        
        List issues = IssuePeer.doSelect(crit);
        rebuildMonitor.setNoIssues(issues.size());
        
        for(Iterator issuei = issues.iterator(); issuei.hasNext();) 
        {            
            Document doc = document((Issue)issuei.next());
            synchronized(this){
                update(doc);                
                rebuildMonitor.issueProcessed();
            }
            
            if(rebuildMonitor.iscancelled()) return;
        }  

        synchronized(this)
        {
            optimize(true);        
            flush();
        }
    }
              
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void initialize()
        throws Exception
    {
        Configuration cfg = Turbine.getConfiguration().subset("searchindex");
        String indexPath = cfg.getString(INDEX_PATH, null);
        String analyzerClassName = cfg.getString(ANALYZER_CLASS, null);
        
        File absIndexPath = getIndexDir(indexPath, applicationRoot);
        
        indexDir = FSDirectory.getDirectory(absIndexPath, new NativeFSLockFactory(absIndexPath));
        
        boolean createIndex = !IndexReader.indexExists(indexDir);
        
        analyzer = createAnalyzer(analyzerClassName);

        writer = new IndexWriter(indexDir, analyzer, createIndex);
 
        if(createIndex) startRebuild();        
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public Map getAttributeValuesMap(boolean commonOnly) throws Exception
    {
       	Map result = null;

        List attributes;
        if(commonOnly)
        {
            attributes = mitList.getCommonAttributes(false);
        }
        else
        {
            attributes = mitList.getAttributes(false,false);
        }

        Map siaValuesMap = searchIssue.getAttributeValuesMap();
        if (attributes != null) 
        {
            result = new LinkedMap((int)(1.25*attributes.size() + 1));
            Iterator i = attributes.iterator();
            while (i.hasNext()) 
            {
                Attribute attribute = (Attribute)i.next();
                String key = attribute.getName().toUpperCase();
                if (siaValuesMap.containsKey(key)) 
                {
                    result.put(key, siaValuesMap.get(key));
                }
                else 
                {
                    AttributeValue aval = AttributeValue
                        .getNewInstance(attribute, searchIssue);
                    searchIssue.addAttributeValue(aval);
                    result.put(key, aval);
                }
            }
        }
        return result;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getUserAttributes()
        throws Exception
    {
        return mitList.getCommonUserAttributes(false);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getLeafRModuleOptions(Attribute attribute)
        throws Exception
    {
        return mitList.getCommonLeafRModuleOptions(attribute);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getCommonOptionTree(Attribute attribute)
        throws Exception
    {
        return mitList.getCommonRModuleOptionTree(attribute);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getAllOptionTree(Attribute attribute)
        throws Exception
    {
        return mitList.getAllRModuleOptionTree(attribute);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public Integer[] getTextScope()
        throws Exception
    {
        if (textScope == null) 
        {
            textScope = getTextScopeForAll();
        }
        return textScope;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Integer[] getTextScopeForAll()
        throws Exception
    {
        Integer[] textScope = null;
        List textAttributes = getQuickSearchTextAttributeValues();
        if (textAttributes != null) 
        {
            textScope = new Integer[textAttributes.size()];
            for (int j=textAttributes.size()-1; j>=0; j--) 
            {
                textScope[j] = ((AttributeValue)
                                textAttributes.get(j)).getAttributeId();
            }
        }
        return textScope;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public void setTextScope(Integer[] v) 
        throws Exception
    {
        this.textScope = v;            
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getQuickSearchTextAttributeValues()
        throws Exception
    {
        return getTextAttributeValues(true);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getTextAttributeValues()
        throws Exception
    {
        return getTextAttributeValues(false);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private List getTextAttributeValues(boolean quickSearchOnly)
        throws Exception
    {
    	Map searchValues = getAttributeValuesMap(true);
        List searchAttributes = new ArrayList(searchValues.size());

        for (Iterator i=searchValues.values().iterator(); i.hasNext();) 
        {
            AttributeValue searchValue = (AttributeValue)i.next();
            if ((!quickSearchOnly || searchValue.isQuickSearchAttribute())
                 && searchValue.getAttribute().isTextAttribute()) 
            {
                searchAttributes.add(searchValue);
            }
        }

        return searchAttributes;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getQuickSearchOptionAttributeValues()
        throws Exception
    {
        Map searchValues = getAttributeValuesMap(true);
		List searchAttributeValues = new ArrayList(searchValues.size());
		
		for (Iterator i= searchValues.values().iterator();i.hasNext();) 
		{
		    AttributeValue searchValue = (AttributeValue)i.next();
		    if (searchValue.isQuickSearchAttribute()
		         && searchValue instanceof OptionAttribute) 
		    {
		        searchAttributeValues.add(searchValue);
		    }
		}
		
		return searchAttributeValues;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void setDefaults(Issue.FederatedId minFid, 
                             Issue.FederatedId maxFid)
        throws Exception
    {
        Module module = singleModule;
        if (module != null) 
        {
            if (minFid != null && minFid.getDomain() == null) 
            {
                minFid.setDomain(module.getScarabInstanceId());
            }
            if (maxFid != null && maxFid.getDomain() == null) 
            {
                maxFid.setDomain(module.getScarabInstanceId());
            }
            if (minFid != null && minFid.getPrefix() == null) 
            {
                minFid.setPrefix(module.getCode());
            }            
        }
        if (maxFid != null && maxFid.getPrefix() == null) 
        {
            if (minFid == null) 
            {
                maxFid.setPrefix(module.getCode());                
            }
            else 
            {
                maxFid.setPrefix(minFid.getPrefix());        
            }
        }
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void buildOptionList(List options, AttributeValue aval)
        throws Exception
    {
        List descendants =  mitList.getDescendantsUnion(aval.getAttributeOption());
        
        // Include the selected attribute value as one of the options
        // to search for.
        options.add(aval.getOptionId());
        
        if (descendants != null && !descendants.isEmpty())
        {
            // Add all applicable child attribute options to the list as well.
            for (Iterator i = descendants.iterator(); i.hasNext();) 
            {
                options.add(((RModuleOption)i.next())
                    .getOptionId());
            }
        }
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private List getTextMatches()
        throws Exception
    {
        TextQuery query = new  TextQuery();

        if (isSimpleTextQuery())
        {
            query.addAttrClauses(getSimpleTextClauses());
        }
        else 
        {
            List setAttValues = getSetAttributeValues();
            for (Iterator i = setAttValues.iterator(); i.hasNext();) 
            {
                AttributeValue aval = (AttributeValue)i.next();

                if (aval instanceof DateAttribute)
                {
                    query.addAttrClause(getDateAttributeClause(aval));
                }
                else if (aval instanceof StringAttribute)
                {
                	AttributeValue copyAval = aval.copy();
                	copyAval.setValue(QueryParser.escape(copyAval.getValue()));
                    query.addAttrClause(copyAval);
                }
            }
        }

        query.addCommentClause(getCommentQuery());
        
        query.setAnd(!getMergePartialTextQueries());

        List matchingIssueIds = null;
        if(!query.isEmpty())
        {
            LuceneSearchIndex LuceneSearchIndex = SearchFactory.getInstance();
            try 
            {
                matchingIssueIds = LuceneSearchIndex.executeQuery(query);    
            }
            finally
            {
                SearchFactory.releaseInstance(LuceneSearchIndex);
            }
        }
        return matchingIssueIds;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private AttributeValue getDateAttributeClause(AttributeValue aval) 
        throws Exception
    {
        //FIXME remove auxDate workaround for date ranges
        AttributeValue auxAval = aval.getChainedValue();

        Date date = parseDate(aval.getValue(), false); 
        Date auxDate = date;
        if(auxAval != null &&
           emptyString2null(auxAval.getValue()) != null)
        {
        	auxDate = parseDate(auxAval.getValue(), true);                        	
        }
        String clause;
        if (date.equals(auxDate))
        {    
        	clause = DateAttribute.internalDateFormat(date);
        }
        else
        {
            clause =
                "[" + DateAttribute.internalDateFormat(date) + " TO " 
                    + DateAttribute.internalDateFormat(auxDate) + "]"
            ;
      
        }
        StringAttribute clauseAV = new StringAttribute();
        clauseAV.setAttributeId(aval.getAttributeId());
        clauseAV.setValue(clause);
        return clauseAV;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private List getSimpleTextClauses() throws Exception
    {
        String clause = getSearchWords();
        List textClauses = new ArrayList();
        Integer[] attributeIds = getTextScope();
        
        for(int i=0;i<attributeIds.length;i++){
            StringAttribute clauseAV = new StringAttribute();
            clauseAV.setAttributeId(attributeIds[i]);
            clauseAV.setValue(clause);
            textClauses.add(clauseAV);
            
        }
        return textClauses;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Criteria getCoreSearchCriteria(List issueIdsMatchedText)
        throws java.lang.Exception
    {
        Criteria crit = new Criteria();

        crit.addSelectColumn(IssuePeer.ISSUE_ID)
            .and(IssuePeer.DELETED, false)
            .and(IssuePeer.MOVED, false);

        crit.setDistinct();

        addMITCriteria(crit);
        
        addIssueIdRangeCriteria(crit);

        addAttributeOptionCriteria(crit);

        addMatchedTextCriteria(crit, issueIdsMatchedText);

        addDateCriteria(crit);

        addUserCriteria(crit);

        addStateChangeCriteria(crit);

        addSortCriteria(crit);
        
        return crit;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addStateChangeCriteria(Criteria crit)
        throws Exception
    {
        Integer oldOptionId = getStateChangeFromOptionId();
        Integer newOptionId = getStateChangeToOptionId();

        if ((oldOptionId != null &&  !oldOptionId.equals(NUMBERKEY_0))
            || (newOptionId != null && !newOptionId.equals(NUMBERKEY_0))
            || getStateChangeFromDate() != null 
            || getStateChangeToDate() != null)
        {
            crit.addAlias(STATE_CHANGE_TABLE, ActivityPeer.TABLE_NAME);
            crit.addJoin( 
                IssuePeer.ISSUE_ID, 
                useAlias(STATE_CHANGE_TABLE,ActivityPeer.ISSUE_ID), 
                Criteria.INNER_JOIN 
            );

            if (oldOptionId == null && newOptionId == null)
            {
                crit.and(useAlias(STATE_CHANGE_TABLE,ActivityPeer.ATTRIBUTE_ID), 
                         getStateChangeAttributeId(),
                         Criteria.EQUAL);
            }
            else
            {
                if (newOptionId != null && !newOptionId.equals(NUMBERKEY_0)) 
                {
                    crit.and(useAlias(STATE_CHANGE_TABLE,ActivityPeer.NEW_OPTION_ID), 
                             newOptionId,
                             Criteria.EQUAL);
                }
                if (oldOptionId != null && !oldOptionId.equals(NUMBERKEY_0))
                {
                    crit.and(useAlias(STATE_CHANGE_TABLE,ActivityPeer.OLD_OPTION_ID), 
                             oldOptionId,
                             Criteria.EQUAL);
                }
            }
            if (getStateChangeFromDate() != null || getStateChangeToDate() != null)
            {
                crit.addAlias(STATE_CHANGE_DATE_TABLE, ActivitySetPeer.TABLE_NAME);

                crit.addJoin( 
                    useAlias(STATE_CHANGE_TABLE, ActivityPeer.TRANSACTION_ID), 
                    useAlias(STATE_CHANGE_DATE_TABLE, ActivitySetPeer.TRANSACTION_ID), 
                    Criteria.INNER_JOIN 
                );
               addDateRangeCriteria( crit, useAlias(STATE_CHANGE_DATE_TABLE, ActivitySetPeer.CREATED_DATE), 
                                getStateChangeFromDate(), getStateChangeToDate());
            }
        }
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addDateCriteria(Criteria crit)
        throws Exception
    {        
        addTransDateRange(crit, "CHANGE_DATE_TABLE", IssuePeer.LAST_TRANS_ID,
                          getMinChangeDate(), getMaxChangeDate());
        addTransDateRange(crit, "CREATE_DATE_TABLE", IssuePeer.CREATED_TRANS_ID,
                          getMinCreationDate(), getMaxCreationDate());
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addUserCriteria(Criteria crit)
        throws Exception
    {        
        List anyUsers = new ArrayList();
        List creatorUsers = new ArrayList();

        for (Iterator i = searchUsers.entrySet().iterator(); i.hasNext();)
        {                
            Map.Entry entry = (Map.Entry)i.next();
            String userId = (String)entry.getKey();
            Set attrIds = (Set)entry.getValue();

            for ( Iterator i2 = attrIds.iterator(); i2.hasNext();)
            {
                String attrId = (String)i2.next();

    	        if(SEARCHING_USER_KEY.equalsIgnoreCase(userId))
    	        {
    	            userId=searchingUser.getUserId().toString();
    	        }
            
    	        if(ANY_KEY.equals(attrId))
    	        {
    	        	anyUsers.add(userId);
    	        }
    	        else if (CREATED_BY_KEY.equals(attrId)) 
    	        {
    	            creatorUsers.add(userId);
    	        }
    	        else 
    	        {
    	           //Normal user attributes will be added as attributes in 'addAttributeOptionCriteria'.
    	        }

            }
        }

        if (anyUsers.size()>0 || creatorUsers.size()>0)
        {
            crit.addAlias("USER_TABLE", ActivityPeer.TABLE_NAME);
            crit.addJoin( 
                IssuePeer.ISSUE_ID, 
                useAlias("USER_TABLE",ActivityPeer.ISSUE_ID), 
                Criteria.INNER_JOIN 
            );
        }                

        if (anyUsers.size()>0)
        {
            crit.addIn(useAlias("USER_TABLE",ActivityPeer.NEW_USER_ID), anyUsers);
        }                                     
        
        if (anyUsers.size()>0 || creatorUsers.size()>0)
        {
            List anyAndCreators = new ArrayList();
            anyAndCreators.addAll(anyUsers);
            anyAndCreators.addAll(creatorUsers);

            crit.addAlias("CREATOR_USER_TABLE", ActivitySetPeer.TABLE_NAME);
            crit.addJoin( 
                IssuePeer.CREATED_TRANS_ID, 
                useAlias("CREATOR_USER_TABLE",ActivitySetPeer.TRANSACTION_ID), 
                Criteria.INNER_JOIN 
            );

            Criteria.Criterion userIds4anyAndCreators = crit.getNewCriterion(
                useAlias("CREATOR_USER_TABLE",ActivitySetPeer.CREATED_BY),
                anyAndCreators,
                Criteria.IN
            );

            Criteria.Criterion c = crit.getCriterion(useAlias("USER_TABLE",ActivityPeer.NEW_USER_ID));
            if(c!=null)
            {
            	c.or(userIds4anyAndCreators);
            }
            else
            {
            	crit.add(userIds4anyAndCreators);
            }
        }
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addIssueIdRangeCriteria(Criteria crit)
        throws java.lang.Exception
    {
        Issue.FederatedId minFid = null;
        Issue.FederatedId maxFid = null;

        if(minId != null)
        {
            minFid = new Issue.FederatedId(minId);
        }
        if(maxId != null)
        {
            maxFid = new Issue.FederatedId(maxId);
        }
        setDefaults(minFid, maxFid);

        if ( minFid != null
          && maxFid != null
          && (   minFid.getCount() > maxFid.getCount() 
              || !StringUtils.equals(minFid.getPrefix(), maxFid.getPrefix())
              || !StringUtils.equals(minFid.getDomain(), maxFid.getDomain())))
        {
            throw new ScarabException(L10NKeySet.ExceptionIncompatibleIssueIds, minId, maxId);
        }
        else 
        {
            addIssueIdCrit(crit, minFid, Criteria.GREATER_EQUAL );
            addIssueIdCrit(crit, maxFid, Criteria.LESS_EQUAL );
        }        
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addAttributeOptionCriteria(Criteria crit)
        throws java.lang.Exception
    {
        List setAttValues = getSetAttributeValues();

		//get attributes avlues as flat list
        Map attrMap = new HashMap((int)(setAttValues.size()*1.25));
        for (int j=0; j<setAttValues.size(); j++) 
        {
            AttributeValue multiAV = (AttributeValue)setAttValues.get(j);
            if (multiAV instanceof OptionAttribute)
            {                
                //pull any chained values out to create a flat list
                List flatOptions = new ArrayList();
                List chainedValues = multiAV.getValueList();
                for (int i=0; i<chainedValues.size(); i++) 
                {
                    AttributeValue aval = (AttributeValue)chainedValues.get(i);
                    Integer optionId = aval.getOptionId();
                    if(optionId == null)
                    {
                        continue;
                    }
                    if (optionId.intValue() != 0) // Empty value is 0
                    {
                        buildOptionList(flatOptions, aval);
                    }
                    else
                    {
                        flatOptions.add(optionId);
                    }
                }

                Integer attributeId = multiAV.getAttributeId();
                attrMap.put(attributeId, flatOptions);
            }
        }

		//add misc attribute values for search
        for (Iterator i=attrMap.entrySet().iterator(); i.hasNext();) 
        {
            Map.Entry options4Attribute = (Map.Entry)i.next();
            List options = (List) options4Attribute.getValue();
            Integer attributeId = (Integer) options4Attribute.getKey();
            String alias = "av" + attributeId;
            
            crit.addAlias(alias, AttributeValuePeer.TABLE_NAME);
            joinAttributeValue(crit, alias, attributeId, Criteria.LEFT_JOIN);
             
            crit.andIn(useAlias(alias, AttributeValuePeer.OPTION_ID), options );

            if (options.contains(NUMBERKEY_0)) //is 'empty' option selected?
            {                
                crit.or(useAlias(alias, AttributeValuePeer.OPTION_ID), (Object) null, Criteria.ISNULL);
            }
        }

        Map searchUserAttributes = getSearchUserAttributes();
        
		//add values for user attributes
        for (Iterator i=searchUserAttributes.entrySet().iterator(); i.hasNext();) 
        {
        	
            Map.Entry entry = (Map.Entry)i.next();
            String strAttributeId = (String)entry.getKey();
            Set userIds = (Set)entry.getValue();
            List searchUsersList = new ArrayList();
        	
            if(!ANY_KEY.equals(strAttributeId)
        			&& !CREATED_BY_KEY.equals(strAttributeId)){
        		int attributeId = Integer.parseInt(strAttributeId);
            	//add search values for user attributes
            	String alias = "av" + attributeId;            
                crit.addAlias(alias, AttributeValuePeer.TABLE_NAME);
                joinAttributeValue(crit, alias, attributeId, Criteria.LEFT_JOIN);
                
                for ( Iterator i2 = userIds.iterator(); i2.hasNext();)
                {          	           	
                	String strUserId = (String)i2.next();
                	if(SEARCHING_USER_KEY.equalsIgnoreCase(strUserId)) 
        	        {
                		//Special user criteria. These are handled by method 'addUserCriteria'.
        	        }
        	        else{
    	                searchUsersList.add(strUserId);
        	        }
                }
                crit.andIn(useAlias(alias, AttributeValuePeer.USER_ID), searchUsersList );
        	}                      
            
        }

    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getQueryResults()
        throws Exception
    {
    	List queryResults = Collections.EMPTY_LIST;            
        Criteria c = getSearchCriteria();
        if(c!=null)
        {
            queryResults = getQueryResults(c);
        }
        return queryResults;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public int getIssueCount()
        throws Exception
    {
        int count = 0;
        Criteria c = getSearchCriteria();
        if(c!=null)
        {
            count = (new CachedQuery(c, true)).getRowCount();
        }
        return count;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Criteria getSearchCriteria()
        throws Exception
    {
        Criteria c = null;
    	if (isSearchAllowed) 
        {
            List issueIdsMatchedText = getTextMatches();
            
            if (issueIdsMatchedText==null || issueIdsMatchedText.size() > 0) 
            {            
            	c = getCoreSearchCriteria(issueIdsMatchedText);
            }
        }
        return c;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private List getQueryResults(Criteria c)
        throws Exception
    {
        return new QueryResultList(new CachedQuery(c, false));
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public void setQueryKey(String key)
        throws Exception
    {
    }
              
// in java/org/tigris/scarab/util/Email.java
public static void sendEmail(EmailContext context, Module module,
                                    Object fromUser, Object replyToUser,
                                    ScarabUser toUser, String template)
            throws Exception
    {
        Collection toUsers = new ArrayList(2);
        toUsers.add(toUser);
        sendEmail(context, module, fromUser, replyToUser, toUsers, null,
                template);
    }
              
// in java/org/tigris/scarab/util/Email.java
public static void sendEmail(EmailContext context, Module module,
                                    Object fromUser, Object replyToUser,
                                    Collection toUsers, Collection ccUsers,
                                    String template) 
        throws Exception
    {
        if (!GlobalParameterManager.getBoolean(GlobalParameter.EMAIL_ENABLED,
                module))
        {
            return;
        }

        //
        // To avoid any NullPointerExceptions, create
        // empty lists of to: and cc: users if the
        // collections are null.
        //
        if (toUsers == null)
        {
            toUsers = new ArrayList();
        }

        if (ccUsers == null)
        {
            ccUsers = new ArrayList();
        }

        //
        // Remove duplicate addresses from the cc: list
        //
        ccUsers.removeAll(toUsers);        

        Map userLocaleMap = groupAddressesByLocale(module, toUsers, ccUsers);

        for (Iterator i = userLocaleMap.keySet().iterator(); i.hasNext();)
        {
            Locale locale = (Locale) i.next();
            List[] toAndCC = (List[]) userLocaleMap.get(locale);
            List to = toAndCC[TO];
            List cc = toAndCC[CC];

            sendEmailInLocale(context, module, fromUser, replyToUser, to, cc,
                              template, locale);
        }

    }
              
// in java/org/tigris/scarab/util/Email.java
private static void sendEmailInLocale(EmailContext context, Module module,
                                          Object fromUser, Object replyToUser,
                                          List toAddresses, List ccAddresses,
                                          String template, Locale locale)
        throws Exception
    {
        log.debug("Sending email for locale=" + locale);

        // get reference to l10n tool, so we can alter the locale per email
        ScarabLocalizationTool l10n = new ScarabLocalizationTool();
        context.setLocalizationTool(l10n);
        l10n.init(locale);

        Email te = getEmail(context, module, fromUser, replyToUser, template);

        final String charSet = getCharset(locale);
        te.setCharset(charSet);
        context.put("charSet", new String(charSet));
        
        //te.addHeader("Content-Base: "");

        boolean atLeastOneTo = false;
        for (Iterator iTo = toAddresses.iterator(); iTo.hasNext();)
        {
            InternetAddress a = (InternetAddress) iTo.next();
            log.debug("Adding To: email[" + a.getAddress() + "], name["+a.getPersonal()+"]");
            te.addTo(a.getAddress(), a.getPersonal());
            atLeastOneTo = true;
        }
        for (Iterator iCC = ccAddresses.iterator(); iCC.hasNext();)
        {
            InternetAddress a = (InternetAddress) iCC.next();
            String email = a.getAddress();
            String name = a.getPersonal();

            
            // template email requires a To: user, it does seem possible
            // to send emails with only a CC: user, so not sure if this
            // is a bug to be fixed in TemplateEmail.  Might not be good
            // form anyway.  So if there are no To: users, upgrade CC's.
            if (atLeastOneTo)
            {
                log.debug("Adding CC: email[" + email + "], name["+name+"]");
                te.addCc(email, name);
            }
            else
            {
                log.debug("Adding to: email[" + email + "], name["+name+"]");
                te.addTo(email, name);
                // We've added one To: user and TemplateEmail should be
                // happy. No need to move all CC: into TO:
                atLeastOneTo = true;
            }
        }

        // Email threading -- applicable to issue related notifications
        Issue issue = null;
        String emailReferences = null;
        if(context.containsKey("issue"))
        {
            issue = (Issue) context.get("issue");
            emailReferences = null != issue.getEmailReferences()
                    ? issue.getEmailReferences()
                    : "";
            if(0 != emailReferences.length())
            {
                te.addHeader("References", emailReferences);
            }
        }

        String newEmailReference = null;
        try
        {
            log.debug("Sending email ...");
            newEmailReference = te.send();
            log.debug("... sent " + newEmailReference);
        }
        catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }

        if(null!=emailReferences && null!=newEmailReference)
        {
            // we record, within the varchar(2000) limit,
            // the MessageID of every mail sent if it's related to an issue change 
            // There must be an error in the length calculation, which sometimes causes
            // the issue.save() to throw an illegalLength exception. I tried to take care
            // of this here. [HD]

            if(emailReferences.length()>0) emailReferences += ' ';
            emailReferences += newEmailReference; 

            if(emailReferences.length() > 2000)
            {
                emailReferences = emailReferences.substring(
                        emailReferences.indexOf('<', emailReferences.length() - 2000));
            }
            try
            {
                issue.setEmailReferences(emailReferences);
                issue.save();
            }
            catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
        }
    }
              
// in java/org/tigris/scarab/util/Email.java
private static Map groupAddressesByLocale(Module module,
                                              Collection toUsers,
                                              Collection ccUsers)
        throws Exception
    {
        Map result = new HashMap();
        for (Iterator iter = toUsers.iterator(); iter.hasNext();)
        {
            fileUser(result, (ScarabUser) iter.next(), module, TO);
        }

        for (Iterator iter = ccUsers.iterator(); iter.hasNext();)
        {
            fileUser(result, (ScarabUser) iter.next(), module, CC);
        }
        return result;
    }
              
// in java/org/tigris/scarab/util/Email.java
private static void fileUser(Map userLocaleMap, ScarabUser user,
                                 Module module, int toOrCC) throws Exception
    {
        if(!isArchiveUser(user))
        {
            fileAddress(userLocaleMap, new InternetAddress(user.getEmail(), 
                user.getName()), chooseLocale(user, module), toOrCC);
        }
        else
        {
            Set<String> archivingMailAddresses = module.getArchivingMailAddresses();
            for(Iterator<String> addresses= archivingMailAddresses.iterator();addresses.hasNext();)
            {
                fileAddress(userLocaleMap, new InternetAddress((String)addresses.next(),
                    user.getName()), chooseLocale(user, module), toOrCC);

            }
        }
    }
              
// in java/org/tigris/scarab/util/Email.java
private static Email getEmail(EmailContext context, Module module,
                                  Object fromUser, Object replyToUser,
                                  String template) throws Exception
    {
        final boolean bSendHtmlMail =
          Turbine.getConfiguration().getBoolean(ScarabConstants.EMAIL_IN_HTML_KEY, true);

        String htmlTemplate = null;
        
        if (context == null)
        {
            context = new EmailContext();
        }

        if (template == null)
        {
            template = Turbine.getConfiguration().getString(
                    "scarab.email.default.template", "Default.vm");
        }
        htmlTemplate = appendTemplateSuffix(template, "Html");
        
        Email te = new Email();
        te.setContext(context);

        setDebug(te); // Activate debug if enabled
        
        setAuth(te); // Activate authentication if configured

        // Set the plain text template
        log.debug("Add plain template ["+template+"]");
        te.setTextTemplate(prependDir(template));
        
        // Set the HTML template
        if (bSendHtmlMail)
        {
            final String templatePath = prependDir(htmlTemplate);
            VelocityEmailService ves = (VelocityEmailService)
                TurbineServices.getInstance().getService(EmailService.SERVICE_NAME);
            if (ves.templateExists(templatePath))
            {
                log.debug("Add HTML template ["+htmlTemplate+"]");
                te.setHtmlTemplate(templatePath);
            }
        }

        EmailLink el = EmailLinkFactory.getInstance(module);
        context.setLinkTool(el);

        String[] nameAndAddr = getNameAndAddress(fromUser);
        te.setFrom(nameAndAddr[1], nameAndAddr[0]);

        nameAndAddr = getNameAndAddress(replyToUser);
        log.debug("Add from name["+nameAndAddr[0]+"], address["+nameAndAddr[1]+"]");
        te.addReplyTo(nameAndAddr[1], nameAndAddr[0]);

        String subjectTemplate = context.getSubjectTemplate();
        /* If we haven't been given a subject template, infer its name from the
         * plain text template name
         * eg IssueActivity.vm -> IssueActivitySubject.vm
         */
        if (subjectTemplate == null)
        {
            subjectTemplate = appendTemplateSuffix(template, "Subject");
        }

        String subjectText = getSubject(context, subjectTemplate);
        log.debug("Add subject ["+subjectText+"]");        
        te.setSubject(subjectText);
        return te;
    }
              
// in java/org/tigris/scarab/util/EmailLink.java
public EmailLink getIssueIdLink(Issue issue)
        throws Exception
    {
        /**
         * The following construction adds the issueId to a local Configuration instance.
         * The so emailConfig will later be used to resolve configuration template which
         * may contain the issueId as property key. See the toString() method for further details.
         */
        CompositeConfiguration compositConfig = new CompositeConfiguration(Turbine.getConfiguration());
        emailConfig = compositConfig;
        Configuration dynamicConfig = new BaseConfiguration();
        compositConfig.addConfiguration(dynamicConfig);
        dynamicConfig.addProperty("issueId", issue.getUniqueId());
        
        this.addPathInfo(ScarabConstants.ID, issue.getUniqueId());
        return this;
    }
              
// in java/org/tigris/scarab/util/EmailLink.java
public EmailLink getServerContext()
        throws Exception
    {
        this.pathInfo.clear();
        isBaseName = true;
        return this;
    }
(Domain) ScarabRuntimeException 8 
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void save() 
    {
        try
        {
            
            super.save();
        }
        catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/services/ServiceManager.java
public synchronized Object lookup(Class serviceClass)
    {
        Object serviceInstance;
        YaafiComponentService yaafi = getService();
        try{
            serviceInstance =  yaafi.lookup(serviceClass.getName());
        } 
        catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
        return serviceInstance;
    }
              
// in java/org/tigris/scarab/services/ServiceManager.java
public static YaafiComponentService getService()
    {
        YaafiComponentService yaafi = null;
        try{
            yaafi = (YaafiComponentService) TurbineServices.getInstance().getService(
                    YaafiComponentService.SERVICE_NAME);
        } 
        catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
        return yaafi;
        
    }
              
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }

        JCSCache = JCS.getInstance(SCARAB_CACHE_REGION);

        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }

    }
              
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
        maps = new WeakHashMap();
        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
        
    }
              
// in java/org/tigris/scarab/services/cache/ScarabCache.java
public static final ScarabCacheService getService() {
        if (scarabCacheService == null) {
            try {
                ServiceManager sm = ServiceManager.getInstance();
                scarabCacheService = (ScarabCacheService) sm.lookup(ScarabCacheService.class);
            } catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
        }
        return scarabCacheService;
    }
              
// in java/org/tigris/scarab/util/ComponentLocator.java
private static Object lookup(Class clazz) 
    {
		try 
        {
            ServiceManager sm = ServiceManager.getInstance();
			return sm.lookup(clazz);
		} catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
	}
              
// in java/org/tigris/scarab/util/word/SearchFactory.java
public static LuceneSearchIndex getInstance()  
    {
        LuceneSearchIndex result = LuceneSearchIndex;

        if (result == null) 
        {
            
            try{
                ServiceManager sm = ServiceManager.getInstance();
                return (LuceneSearchIndex) sm.lookup(LuceneSearchIndex.class);
            } 
            catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
        }
        return result;
    }
8
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
              
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
              
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
              
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
              
// in java/org/tigris/scarab/services/cache/ScarabCache.java
catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
              
// in java/org/tigris/scarab/util/ComponentLocator.java
catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
              
// in java/org/tigris/scarab/util/word/SearchFactory.java
catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
0
(Lib) LoginException 7 
              
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean login() throws LoginException {
		Callback[] calls = new Callback[3];
        LDAPUserInfoCallback ldapUserInfo =  new LDAPUserInfoCallback();
		calls[0] = new NameCallback("name");
		calls[1] = new PasswordCallback("Password", false);
        calls[2] =  ldapUserInfo;
		
		if (callbackHandler == null)
			throw new LoginException("callback is null");

		try {
			callbackHandler.handle(calls);
		} catch (IOException e) {
			throw new LoginException(e.toString());
		} catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}

		cbName = ((NameCallback) calls[0]).getName();
		if (cbName.equals(null))
			throw new LoginException("name must not be null");
		
		cbPassword = String.valueOf(((PasswordCallback) (calls[1])).getPassword());
		if (cbPassword.equals(null))
			throw new LoginException("password must not be null");
		
		try {
			props = new Hashtable();
			props.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
			props.put(Context.PROVIDER_URL, options.get(HOST_KEY));
            ctx = new InitialDirContext(props);
            SearchControls cons = new SearchControls();
            cons.setSearchScope(SearchControls.SUBTREE_SCOPE);
            NamingEnumeration results = ctx.search((String)options.get(BASEDN_KEY),"uid={0}",new Object[] { cbName },cons);
            Attributes attributes = null;
            String principal = null;
            while (results.hasMore()){
                SearchResult sr = (SearchResult)results.next();
                attributes = sr.getAttributes();
                principal = sr.getName() + "," + options.get(BASEDN_KEY);
            }
            if ( attributes == null || principal == null){
                throw new LoginException("No User Found");
            }
            ctx.close();
			props.put(Context.SECURITY_PRINCIPAL, principal);
			props.put(Context.SECURITY_CREDENTIALS, cbPassword);
			props.put(Context.SECURITY_AUTHENTICATION, "simple");
			ctx = new InitialDirContext(props);
			verification = true;
            ldapUserInfo.setEmail(attributes.get("mail").get().toString());
            ldapUserInfo.setGivenname(attributes.get("givenname").get().toString());
            ldapUserInfo.setSn(attributes.get("sn").get().toString());
			ctx.close();
		} catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
		
		return verification;
	}
3
              
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (IOException e) {
			throw new LoginException(e.toString());
		}
              
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}
              
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
4
              
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean abort() throws LoginException {
		return true;
	}
              
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean commit() throws LoginException {
		return true;
	}
              
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean login() throws LoginException {
		Callback[] calls = new Callback[3];
        LDAPUserInfoCallback ldapUserInfo =  new LDAPUserInfoCallback();
		calls[0] = new NameCallback("name");
		calls[1] = new PasswordCallback("Password", false);
        calls[2] =  ldapUserInfo;
		
		if (callbackHandler == null)
			throw new LoginException("callback is null");

		try {
			callbackHandler.handle(calls);
		} catch (IOException e) {
			throw new LoginException(e.toString());
		} catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}

		cbName = ((NameCallback) calls[0]).getName();
		if (cbName.equals(null))
			throw new LoginException("name must not be null");
		
		cbPassword = String.valueOf(((PasswordCallback) (calls[1])).getPassword());
		if (cbPassword.equals(null))
			throw new LoginException("password must not be null");
		
		try {
			props = new Hashtable();
			props.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
			props.put(Context.PROVIDER_URL, options.get(HOST_KEY));
            ctx = new InitialDirContext(props);
            SearchControls cons = new SearchControls();
            cons.setSearchScope(SearchControls.SUBTREE_SCOPE);
            NamingEnumeration results = ctx.search((String)options.get(BASEDN_KEY),"uid={0}",new Object[] { cbName },cons);
            Attributes attributes = null;
            String principal = null;
            while (results.hasMore()){
                SearchResult sr = (SearchResult)results.next();
                attributes = sr.getAttributes();
                principal = sr.getName() + "," + options.get(BASEDN_KEY);
            }
            if ( attributes == null || principal == null){
                throw new LoginException("No User Found");
            }
            ctx.close();
			props.put(Context.SECURITY_PRINCIPAL, principal);
			props.put(Context.SECURITY_CREDENTIALS, cbPassword);
			props.put(Context.SECURITY_AUTHENTICATION, "simple");
			ctx = new InitialDirContext(props);
			verification = true;
            ldapUserInfo.setEmail(attributes.get("mail").get().toString());
            ldapUserInfo.setGivenname(attributes.get("givenname").get().toString());
            ldapUserInfo.setSn(attributes.get("sn").get().toString());
			ctx.close();
		} catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
		
		return verification;
	}
              
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean logout() throws LoginException {
		return true;
	}
(Domain) ScarabLocalizedTorqueException 7 
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void save(final Connection dbCon) 
        throws TorqueException
    {
        // if new, make sure the code has a value.
        if (isNew())
        {

            List result;
            try {
                result = getDuplicatesByNameAndParent(getRealName(), getParentId());
            }
            catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
            if (result.size() > 0)
            {
                throw new ScarabLocalizedTorqueException(
                        new ScarabException(
                                L10NKeySet.ExceptionModuleAllreadyExists,
                        getRealName(), 
                        getParent().getName()));
            }

            final String code = getCode();
            if (code == null || code.length() == 0)
            {
                if (getParentId().equals(ROOT_ID))
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionTopLevelModuleWithoutCode));
                }

                try
                {
                    setCode(getParent().getCode());
                }
                catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            }

            // need to do this before the relationship save below
            // in order to set the moduleid for the new module.
            super.save(dbCon);
            try
            {
                dbCon.commit();
            }
            catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
            if (getOwnerId() == null) 
            {
                throw new ScarabLocalizedTorqueException(new  ScarabException(L10NKeySet.ExceptionSaveNeedsOwner));
            }
            // grant the ower of the module the Project Owner role
            try
            {
                final User user = ScarabUserManager.getInstance(getOwnerId());
 
                final Role role = TurbineSecurity.getRole(PROJECT_OWNER_ROLE);
                grant (user, role);
                setInitialAttributesAndIssueTypes();
            }
            catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
        }
        else
        {
            super.save(dbCon);
        }
        
        // clear out the cache beause we want to make sure that
        // things get updated properly.
        ScarabCache.clear();
    }
4
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
              
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
0
(Domain) ValidationException 7 
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
0 1
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
(Lib) DataBackendException 6 
              
// in java/org/tigris/scarab/om/ScarabModulePeer.java
public static boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        Criteria criteria = new Criteria();
        criteria.addSelectColumn(MODULE_ID);
        String name = ((Module)group).getRealName();
        criteria.add(MODULE_NAME, name);
        criteria.add(PARENT_ID, ((Module)group).getParentId());
        List results = BasePeer.doSelect(criteria);
        if(results.size() > 1)
        {
            throw new DataBackendException("Multiple groups named '" +
                name + "' exist!"); //EXCEPTION
        }
        return (results.size()==1);
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public GroupSet getGroups(Criteria criteria)
        throws DataBackendException
    {
        List groups = null;
        try
        {
            groups = ScarabModulePeer.doSelect(criteria);
        }
        catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
        if (groups == null)
        {
            groups = new ArrayList(0);
        }
        return new GroupSet(groups);
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public void saveGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            if (!((Persistent)group).isNew()) 
            {
                group.save();
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized Group addGroup(Group group) 
        throws DataBackendException, EntityExistsException
    {
        try
        {
            lockExclusive();
            if (((Persistent)group).isNew()) 
            {
                group.save();
                // add the group to system-wide cache
                getAllGroups().add(group);
                return group;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        // the only way we could get here without return/throw tirggered
        // is that the groupExists was true.
        throw new EntityExistsException("Group '" + group + 
            "' already exists"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void removeGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            lockExclusive();
            if (!((Persistent)group).isNew()) 
            {
                ((Module)group).setDeleted(true);
                group.save();
                getAllGroups().remove(group);
            }
        }
        catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void renameGroup(Group group, String name)
        throws DataBackendException, UnknownEntityException
    {
        throw new DataBackendException("rename is not supported"); //EXCEPTION

        /* this stuff is cut-n-paste
        boolean groupExists = false;
        try
        {
            lockExclusive();
            groupExists = checkExists(group);
            if(groupExists)
            {
                ((SecurityObject)group).setName(name);
                Criteria criteria = GroupPeer.buildCriteria(group);
                GroupPeer.doUpdate(criteria);
                return;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("renameGroup(Group,String)" ,e);
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'");
        */
    }
4
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
9
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void createNewUser()
        throws TorqueException, DataBackendException, EntityExistsException
    {
        // get a unique id for validating the user
        final String uniqueId = RandomStringUtils
                .randomAlphanumeric(UNIQUE_ID_MAX_LEN);
        // add it to the perm table
        setConfirmed(uniqueId);
        TurbineSecurity.addUser (this, getPassword());
        setPasswordExpire();
        
        // add any roles the anonymous user has, if she is enabled.
        if(ScarabUserManager.anonymousAccessAllowed())
        {
            final ScarabUserImpl anonymous = (ScarabUserImpl) ScarabUserManager.getAnonymousUser();
            final List/*<ScarabModule>*/ modules = anonymous.getNonGlobalModules();
            for(Iterator it0 = modules.iterator(); it0.hasNext(); )
            {
                final ScarabModule module = (ScarabModule)it0.next();
                final List/*<Roles>*/ roles = anonymous.getRoles(module);
                for(Iterator it1 = roles.iterator(); it1.hasNext(); )
                {
                    try 
                    {
                        final Role role = (Role) it1.next();
                        TurbineSecurity.grant(this, (Group) module, role);

                        // TODO: Needs to be refactored into the Users system?
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.GET_ACL);
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable) role, module);
                        
                    }catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/om/ScarabModulePeer.java
public static boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        Criteria criteria = new Criteria();
        criteria.addSelectColumn(MODULE_ID);
        String name = ((Module)group).getRealName();
        criteria.add(MODULE_NAME, name);
        criteria.add(PARENT_ID, ((Module)group).getParentId());
        List results = BasePeer.doSelect(criteria);
        if(results.size() > 1)
        {
            throw new DataBackendException("Multiple groups named '" +
                name + "' exist!"); //EXCEPTION
        }
        return (results.size()==1);
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public GroupSet getGroups(Criteria criteria)
        throws DataBackendException
    {
        List groups = null;
        try
        {
            groups = ScarabModulePeer.doSelect(criteria);
        }
        catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
        if (groups == null)
        {
            groups = new ArrayList(0);
        }
        return new GroupSet(groups);
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public void saveGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            if (!((Persistent)group).isNew()) 
            {
                group.save();
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized Group addGroup(Group group) 
        throws DataBackendException, EntityExistsException
    {
        try
        {
            lockExclusive();
            if (((Persistent)group).isNew()) 
            {
                group.save();
                // add the group to system-wide cache
                getAllGroups().add(group);
                return group;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        // the only way we could get here without return/throw tirggered
        // is that the groupExists was true.
        throw new EntityExistsException("Group '" + group + 
            "' already exists"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void removeGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            lockExclusive();
            if (!((Persistent)group).isNew()) 
            {
                ((Module)group).setDeleted(true);
                group.save();
                getAllGroups().remove(group);
            }
        }
        catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void renameGroup(Group group, String name)
        throws DataBackendException, UnknownEntityException
    {
        throw new DataBackendException("rename is not supported"); //EXCEPTION

        /* this stuff is cut-n-paste
        boolean groupExists = false;
        try
        {
            lockExclusive();
            groupExists = checkExists(group);
            if(groupExists)
            {
                ((SecurityObject)group).setName(name);
                Criteria criteria = GroupPeer.buildCriteria(group);
                GroupPeer.doUpdate(criteria);
                return;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("renameGroup(Group,String)" ,e);
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'");
        */
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
protected boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        return ScarabModulePeer.checkExists(group);
    }
              
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
public User getAuthenticatedUser(String username, String password)
        throws DataBackendException, UnknownEntityException, 
            PasswordMismatchException {
        LDAPUserInfoCallback info = authenticate(username, password);

        /* First try to auth from ldap */
        if (info != null) {
            /* Check if user exists */
            if (!super.userManager.accountExists(username)) {
                try {
                    super.userManager.createAccount(createUser(username,
                            password, info), password);
                } catch (EntityExistsException e) {
                }

                
            } else {
                User curruser = userManager.retrieve(username);
                copyProps(curruser, info);

                String encrypted = TurbineSecurity.encryptPassword(password);

                if (!encrypted.equals(curruser.getPassword())) {
                    curruser.setPassword(encrypted);
                }

                userManager.store(curruser);
            }

            return userManager.retrieve(username);
        }

        return userManager.retrieve(username, password);
    }
(Lib) IllegalStateException 6 
              
// in java/org/tigris/scarab/om/MITList.java
private void assertNotEmpty()
    {
        if (isEmpty())
        {
            throw new IllegalStateException("method should not be called on an empty list."); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/om/MITList.java
public Module getModule() throws TorqueException
    {
        if (!isSingleModule())
        {
            throw new IllegalStateException(
                "method should not be called on"
                    + " a list including more than one module."); //EXCEPTION
        }
        return getModule(getFirstItem());
    }
              
// in java/org/tigris/scarab/om/MITList.java
public IssueType getIssueType() throws TorqueException
    {
        if (!isSingleIssueType())
        {
            throw new IllegalStateException(
                "method should not be called on"
                    + " a list including more than one issue type."); //EXCEPTION
        }
        return getFirstItem().getIssueType();
    }
              
// in java/org/tigris/scarab/om/MITListItem.java
public String getAttributeDisplayName(final Attribute attribute) throws TorqueException
    {
        if (!isSingleIssueType())
        {
            // FIXME: we should in fact use isSingleModuleIssueType() here
            //        but the reference of multiple modules 
            //        is represented by moduleId == MULTIPE_KEY,
            //        which has the value of 0
            //        which is also the id of the global module
            //        probably null is a better value for MULTIPE_KEY
            throw new IllegalStateException(
               "method should not be called on an item " +
               "including issue types");
        }
        Module module = getModule();
        IssueType issueType = getIssueType();
        RModuleAttribute rma = module.getRModuleAttribute(attribute, issueType);
        String displayValue;
        
        // FIXME: When would the rma be null ? I got this error today, while performing a cross module
        //        query. But i couldn't find the cause.
        //        It may be related to an inconsistent submodule definition ...
        //        In order to debug this behaviour, i added a generic displayValue here. Now the NPE
        //        is away, but the generic displayValues don't appear either on the GUI. So whatever happens
        //        here, the associated items seem to be irrelevant on the GUI... To be further examined!
        if(rma != null)
        {
        	displayValue = rma.getDisplayValue();
        }
        else
        {
        	displayValue = "" + attribute.getName() + ":" + issueType.getName();
        }
        return displayValue;
    }
              
// in java/org/tigris/scarab/util/IteratorWithSize.java
public void remove()
    {
        throw new IllegalStateException("next() will throw exception, so it is "
                                        + "not possible to call this method."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/util/WindowIterator.java
public void remove()
    {
        throw new IllegalStateException("next() will throw exception, it is "
                                        + "not possible to call this method."); //EXCEPTION
    }
0 0
(Lib) InitializationException 6 
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void init()
        throws InitializationException
    {
        try
        {
            initVelocity();
            // Register with the template service.
            registerConfiguration("ve");
            setInit(true);
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private void initVelocity()
        throws InitializationException
    {
        // Now we have to perform a couple of path translations
        // for our log file and template paths.
        String path = getRealPath(
            getConfiguration().getString(VelocityEngine.RUNTIME_LOG, null));

        if (path != null && path.length() > 0)
        {
            getConfiguration().setProperty(VelocityEngine.RUNTIME_LOG, path);
        }
        else
        {
            String msg = EmailService.SERVICE_NAME + " runtime log file " +
                "is misconfigured: '" + path + "' is not a valid log file";

            throw new Error(msg); //EXCEPTION
        }

        // Get all the template paths where the velocity
        // runtime should search for templates and
        // collect them into a separate vector
        // to avoid concurrent modification exceptions.
        String key;
        List keys = new ArrayList();
        for (Iterator i = getConfiguration().getKeys(); i.hasNext();)
        {
            key = (String) i.next();
            if (key.endsWith(RESOURCE_LOADER_PATH))
            {
                keys.add(key);
            }
        }

        // Loop through all template paths, clear the corresponding
        // velocity properties and translate them all to the webapp space.
        int ind;
        List paths;
        String entry;
        for (Iterator i = keys.iterator(); i.hasNext();)
        {
            key = (String) i.next();
            paths = getConfiguration().getList(key,null);
            if (paths != null)
            {
                velocityEngine.clearProperty(key);
                getConfiguration().clearProperty(key);

                for (Iterator j = paths.iterator(); j.hasNext();)
                {
                    path = (String) j.next();
                    if (path.startsWith(JAR_PREFIX + "file"))
                    {
                        // A local jar resource URL path is a bit more
                        // complicated, but we can translate it as well.
                        ind = path.indexOf("!/");
                        if (ind >= 0)
                        {
                            entry = path.substring(ind);
                            path = path.substring(9,ind);
                        }
                        else
                        {
                            entry = "!/";
                            path = path.substring(9);
                        }
                        path = JAR_PREFIX + "file:" + getRealPath(path) +
                            entry;
                    }
                    else if (path.startsWith(ABSOLUTE_PREFIX))
                    {
                        path = path.substring (ABSOLUTE_PREFIX.length(),
                                               path.length());
                    }
                    else if (!path.startsWith(JAR_PREFIX))
                    {
                        // But we don't translate remote jar URLs.
                        path = getRealPath(path);
                    }
                    // Put the translated paths back to the configuration.
                    getConfiguration().addProperty(key,path);
                }
            }
        }

        try
        {
            velocityEngine.setExtendedProperties(ConfigurationConverter
                    .getExtendedProperties(getConfiguration()));

            velocityEngine.init();
        }
        catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/services/DatabaseInitializer.java
public void init()
        throws InitializationException
    {
        try
        {
            String dbState =
                GlobalParameterManager.getString(DB_L10N_STATE);
            if (PRE_L10N.equals(dbState) || STARTED_L10N.equals(dbState))
            {
                long start = System.currentTimeMillis();
                Log.get().info("New scarab database; localizing strings for '" +
                               ScarabConstants.DEFAULT_LOCALE.getDisplayName() + "'...");
                GlobalParameterManager.setString(DB_L10N_STATE, STARTED_L10N);
                initdb(ScarabConstants.DEFAULT_LOCALE);     
                GlobalParameterManager.setString(DB_L10N_STATE, POST_L10N);
                Log.get().info("Done localizing.  Time elapsed = " + 
                    (System.currentTimeMillis()-start)/1000.0 + " s");
            }

            checkNewHttpParameters();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }

        // indicate that the service initialized correctly
        setInit(true);
    }
              
// in java/org/tigris/scarab/services/TorqueService.java
public void init()
        throws InitializationException
    {
        try
        {
            Torque.init(Turbine.getConfiguration());
            Log.get("org.apache.fulcrum").info("  Loading om instances via managers...");
            loadOM();
            Log.get("org.apache.fulcrum").info("  Done loading om instances.");
        }
        catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }

        // indicate that the service initialized correctly
        setInit(true);
    }
              
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }

        JCSCache = JCS.getInstance(SCARAB_CACHE_REGION);

        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }

    }
              
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
        maps = new WeakHashMap();
        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
        
    }
6
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/services/TorqueService.java
catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }
              
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }
              
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
5
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void init()
        throws InitializationException
    {
        try
        {
            initVelocity();
            // Register with the template service.
            registerConfiguration("ve");
            setInit(true);
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private void initVelocity()
        throws InitializationException
    {
        // Now we have to perform a couple of path translations
        // for our log file and template paths.
        String path = getRealPath(
            getConfiguration().getString(VelocityEngine.RUNTIME_LOG, null));

        if (path != null && path.length() > 0)
        {
            getConfiguration().setProperty(VelocityEngine.RUNTIME_LOG, path);
        }
        else
        {
            String msg = EmailService.SERVICE_NAME + " runtime log file " +
                "is misconfigured: '" + path + "' is not a valid log file";

            throw new Error(msg); //EXCEPTION
        }

        // Get all the template paths where the velocity
        // runtime should search for templates and
        // collect them into a separate vector
        // to avoid concurrent modification exceptions.
        String key;
        List keys = new ArrayList();
        for (Iterator i = getConfiguration().getKeys(); i.hasNext();)
        {
            key = (String) i.next();
            if (key.endsWith(RESOURCE_LOADER_PATH))
            {
                keys.add(key);
            }
        }

        // Loop through all template paths, clear the corresponding
        // velocity properties and translate them all to the webapp space.
        int ind;
        List paths;
        String entry;
        for (Iterator i = keys.iterator(); i.hasNext();)
        {
            key = (String) i.next();
            paths = getConfiguration().getList(key,null);
            if (paths != null)
            {
                velocityEngine.clearProperty(key);
                getConfiguration().clearProperty(key);

                for (Iterator j = paths.iterator(); j.hasNext();)
                {
                    path = (String) j.next();
                    if (path.startsWith(JAR_PREFIX + "file"))
                    {
                        // A local jar resource URL path is a bit more
                        // complicated, but we can translate it as well.
                        ind = path.indexOf("!/");
                        if (ind >= 0)
                        {
                            entry = path.substring(ind);
                            path = path.substring(9,ind);
                        }
                        else
                        {
                            entry = "!/";
                            path = path.substring(9);
                        }
                        path = JAR_PREFIX + "file:" + getRealPath(path) +
                            entry;
                    }
                    else if (path.startsWith(ABSOLUTE_PREFIX))
                    {
                        path = path.substring (ABSOLUTE_PREFIX.length(),
                                               path.length());
                    }
                    else if (!path.startsWith(JAR_PREFIX))
                    {
                        // But we don't translate remote jar URLs.
                        path = getRealPath(path);
                    }
                    // Put the translated paths back to the configuration.
                    getConfiguration().addProperty(key,path);
                }
            }
        }

        try
        {
            velocityEngine.setExtendedProperties(ConfigurationConverter
                    .getExtendedProperties(getConfiguration()));

            velocityEngine.init();
        }
        catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/services/DatabaseInitializer.java
public void init()
        throws InitializationException
    {
        try
        {
            String dbState =
                GlobalParameterManager.getString(DB_L10N_STATE);
            if (PRE_L10N.equals(dbState) || STARTED_L10N.equals(dbState))
            {
                long start = System.currentTimeMillis();
                Log.get().info("New scarab database; localizing strings for '" +
                               ScarabConstants.DEFAULT_LOCALE.getDisplayName() + "'...");
                GlobalParameterManager.setString(DB_L10N_STATE, STARTED_L10N);
                initdb(ScarabConstants.DEFAULT_LOCALE);     
                GlobalParameterManager.setString(DB_L10N_STATE, POST_L10N);
                Log.get().info("Done localizing.  Time elapsed = " + 
                    (System.currentTimeMillis()-start)/1000.0 + " s");
            }

            checkNewHttpParameters();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }

        // indicate that the service initialized correctly
        setInit(true);
    }
              
// in java/org/tigris/scarab/services/TorqueService.java
public void init()
        throws InitializationException
    {
        try
        {
            Torque.init(Turbine.getConfiguration());
            Log.get("org.apache.fulcrum").info("  Loading om instances via managers...");
            loadOM();
            Log.get("org.apache.fulcrum").info("  Done loading om instances.");
        }
        catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }

        // indicate that the service initialized correctly
        setInit(true);
    }
              
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
public void init() throws InitializationException {
		super.init();
        Configuration cfg = Turbine.getConfiguration().subset("scarab.login.ldap");
        if ((cfg != null) && 
        	(getConfiguration().getBoolean("synchronizeOnStartUp",false))) {
			try {
				LDAPSynchronizer syncher = new LDAPSynchronizer(cfg);
				syncher.synchronize(); 
			} catch (NamingException e) {
				log.error("NamingException caught synchronizing accounts: ",e);
			}
        }
	}
(Lib) ParseException 6 
              
// in java/org/tigris/scarab/screens/admin/ActivityList.java
private Date parseDate(String s)
        throws ParseException
    {
        SimpleDateFormat[] sdf = {
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"),
            new SimpleDateFormat("yyyy-MM-dd HH:mm"),
            new SimpleDateFormat("yyyy-MM-dd"),
            new SimpleDateFormat("HH:mm:ss"),
            new SimpleDateFormat("HH:mm")
                };

        Date date = null;
        for (int i=0; i<sdf.length-1; i++) 
        {
            try 
            {
                date = sdf[i].parse(s);
            }
            catch (ParseException e)
            {
                // try the next one
            }
        }

        if (date == null) 
        {
            //TODO [HD] Shouldn't this be better a NPE ?
            //          That better hits the truth...
            throw new ParseException(s + " could not be parsed as a date", 0); //EXCEPTION
        }
        return date;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void validateDate(final BaseDate xmlDate, final boolean required)
    {
        try
        {
            // Report parse error failures even for optional dates.
            if ((xmlDate != null && xmlDate.getDate() == null) && required)
            {
                // Trigger error handling.
                throw new ParseException(null, -1); //EXCEPTION
            }
        }
        catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
    }
              
// in java/org/tigris/scarab/util/ScarabUtil.java
private static Date parseDate(String s, String[] patterns)
        throws ParseException
    {
        if (s == null) 
        {
            throw new ParseException("Input string was null", -1);
        }

        SimpleDateFormat formatter = new SimpleDateFormat();

        for (int i = 0; i < patterns.length; i++) 
        {
        	Date date = null;
        	formatter.applyPattern(patterns[i]);
            try
            {
            	date = formatter.parse(s);
            }
            catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }            
            if (date != null) 
            {
                return date;
            }
        }
        
        throw new ParseException("Date could not be parsed with any"
                                 + " of the provided date patterns.", -1);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Date parseDate(String s, String[] patterns)
        throws ParseException
    {
        if (s == null) 
        {
            throw new ParseException("Input string was null", -1);
        }

        if (formatter == null) 
        {
            formatter = new SimpleDateFormat();
        }
        
        for (int i = 0; i < patterns.length; i++) 
        {
        	Date date = null;
        	formatter.applyPattern(patterns[i]);
            try
            {
            	date = formatter.parse(s);
            }
            catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }            
            if (date != null) 
            {
                return date;
            }
        }
        
        throw new ParseException("Date could not be parsed with any"
                                 + " of the provided date patterns.", -1);
    }
0 19
              
// in java/org/tigris/scarab/attribute/DateAttribute.java
public static Date toDate(String value) throws ParseException
    {
        Date result = internalFormat.parse(value);
        return result;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public long getHoursIdle() throws TorqueException, ParseException
    {
        Date now = new Date();
        Date date = null;
        Date onHoldUntil = null;
        long diffHours = 0;

        if (!isNew()) 
        {
            boolean onHold = isOnHold();
            if(onHold)
            {
                onHoldUntil = getOnHoldUntil(); // on Hold until this date
                if(onHoldUntil == null)
                {
                    return 0; // we are on hold but there is no end date, so we wait forever.
                }
                diffHours = (now.getTime() - onHoldUntil.getTime()) / (1000*60*60);
                if(diffHours < 0)
                {
                    return 0; // onHoldDate not yet reached, so we are not idle by definition
                }
            }
            ActivitySet t = getLastActivitySet();
            if (t == null)
            {
                date = getCreatedDate();
            }
            else 
            {
                date = t.getCreatedDate();
            }
            
            if(onHold)
            {
                if (date.before(onHoldUntil))
                {
                    // The date of last activity was before the onHoldUntil date
                    // In that case we count the end of the onHold period as the
                    // event.
                    date = onHoldUntil;
                }
            }
            
        }
        // Return the difference in hours between now and the last date of activities:
        diffHours = (now.getTime() - date.getTime()) / (1000*60*60);
        return diffHours;
    }
              
// in java/org/tigris/scarab/om/Issue.java
public Date getOnHoldUntil() throws TorqueException, ParseException
    {
        return mystate.getOnHoldUntil();
    }
              
// in java/org/tigris/scarab/screens/admin/ActivityList.java
private Date parseDate(String s)
        throws ParseException
    {
        SimpleDateFormat[] sdf = {
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"),
            new SimpleDateFormat("yyyy-MM-dd HH:mm"),
            new SimpleDateFormat("yyyy-MM-dd"),
            new SimpleDateFormat("HH:mm:ss"),
            new SimpleDateFormat("HH:mm")
                };

        Date date = null;
        for (int i=0; i<sdf.length-1; i++) 
        {
            try 
            {
                date = sdf[i].parse(s);
            }
            catch (ParseException e)
            {
                // try the next one
            }
        }

        if (date == null) 
        {
            //TODO [HD] Shouldn't this be better a NPE ?
            //          That better hits the truth...
            throw new ParseException(s + " could not be parsed as a date", 0); //EXCEPTION
        }
        return date;
    }
              
// in java/org/tigris/scarab/reports/ReportDateRange.java
public Date getMinDate(Locale locale)
    throws ParseException
    {
    	
    	if(minDateString == null || minDateString.trim().equals(""))
        {
    		
    		return null;
    		
    	}
    	
    	return ScarabUtil.parseDate(minDateString, false, locale);
    	
    }
              
// in java/org/tigris/scarab/reports/ReportDateRange.java
public Date getMaxDate(Locale locale)
    throws ParseException
    {
    	
    	if(maxDateString == null || maxDateString.trim().equals(""))
        {
    		
    		return null;
    		
    	}
    	
    	return ScarabUtil.parseDate(maxDateString, false, locale);
    	
    }
              
// in java/org/tigris/scarab/workflow/IssueState.java
public Date getOnHoldUntil() throws TorqueException, ParseException
    {
        Date date = null;
        String attributeName = Environment.getConfigurationProperty("scarab.common.status.onhold.dateProperty", null);
        
        if (attributeName != null)
        {
            AttributeValue dateValue = issue.getAttributeValue(attributeName);
            if(dateValue!=null) 
            {
                String value = dateValue.getValue();
                if (value != null && value.length() > 0)
                {
                    date = DateAttribute.toDate(value);
                }
            }
        }
        return date;
    }
              
// in java/org/tigris/scarab/util/xmlissues/BaseDate.java
public Date getDate()
        throws ParseException
    {
        Date date = null;
        String ts = getTimestamp();
        if (StringUtils.isNotEmpty(ts))
        {
            String format = getFormat();
            boolean haveFormat = StringUtils.isNotEmpty(format);
            try
            {
                SimpleDateFormat sdf =
                    new SimpleDateFormat(haveFormat ? format : DEFAULT_FORMAT);
                sdf.setLenient(false);
                date = sdf.parse(getTimestamp());
            }
            catch (ParseException e)
            {
                if (haveFormat)
                {
                    // When a format was explicitly specified,
                    // propogate any parsing problems.
                    throw e;
                }
            }
        }
        return date;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueEvent(final XmlModule module, final XmlIssue issue)
        throws TorqueException,ScarabException,ParseException
    {
/////////////////////////////////////////////////////////////////////////////////  
        // Get me an issue
        Issue issueOM = null;
        final String issueID = (issue.hasModuleCode() ? "" : module.getCode()) + issue.getId();
        if (getImportTypeCode() == CREATE_SAME_DB || getImportTypeCode() == CREATE_DIFFERENT_DB)
        {
            // Check if the new issue nominates an ID and if the database does
            // not already contain an issue with that ID
            if (issue.getId() != null && IssueManager.getIssueById(issueID) == null)
            {
                // Create the new issue with the nominated ID
                issueOM = createNewIssue(module, issue, issue.getId());
            }
            else
            {
                // Crate the new issue with an automatically allocated ID
                issueOM = createNewIssue(module, issue, null);
            }
        }
        else if (getImportTypeCode() == UPDATE_SAME_DB) // nice to specify just for searching/refactoring
        {
            issueOM = IssueManager.getIssueById(issueID);
            
            if (issueOM == null)
            {
                issueOM = createNewIssue(module, issue, null);
            }
            else
            {
                LOG.debug("Found Issue in db: " + issueOM.getUniqueId());
            }
        }

/////////////////////////////////////////////////////////////////////////////////  

        // Loop over the XML activitySets
        final List activitySets = issue.getActivitySets();
        LOG.debug("-----------------------------------");
        LOG.debug("Number of ActivitySets in Issue: " + activitySets.size());
        for (Iterator itr = activitySets.iterator(); itr.hasNext();)
        {
            final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
            LOG.debug("Processing ActivitySet: " + activitySet.getId());

/////////////////////////////////////////////////////////////////////////////////  
            // Deal with the attachment for the activitySet
            final XmlAttachment activitySetAttachment = activitySet.getAttachment();
            Attachment activitySetAttachmentOM = null;
            if (activitySetAttachment != null)
            {
                if (getImportTypeCode() == UPDATE_SAME_DB)
                {
                    try
                    {
                        activitySetAttachmentOM = AttachmentManager
                            .getInstance(activitySetAttachment.getId());
                        LOG.debug("Found existing ActivitySet Attachment");
                    }
                    catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
                }
                else
                {
                    activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    LOG.debug("Created ActivitySet Attachment object");
                }
            }
            else
            {
                LOG.debug("OK- No Attachment in this ActivitySet");
            }

/////////////////////////////////////////////////////////////////////////////////  
            // Attempt to get the activitySet OM
            boolean alreadyCreated = false;
            ActivitySet activitySetOM = null;
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                try
                {
                    activitySetOM = ActivitySetManager.getInstance(activitySet.getId());
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in db: " + activitySetOM.getActivitySetId());
                }
                catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            }
            else
            {
                // first try to get the ActivitySet from the internal map
                if (activitySetIdMap.containsKey(activitySet.getId()))
                {
                    activitySetOM = ActivitySetManager.getInstance(
                        (String)activitySetIdMap.get(activitySet.getId()));
                    alreadyCreated = true;
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in map: " + activitySetOM.getActivitySetId());
                }
                else // it hasn't been encountered previously
                {
                    activitySetOM = ActivitySetManager.getInstance();
                    LOG.debug("Created new ActivitySet");
                }
            }

            final ScarabUser activitySetCreatedByOM = findUser(activitySet.getCreatedBy());
            
            if (LOG.isDebugEnabled())
            {
                LOG.debug("ActivitySet: " + activitySet.getId() + "; of type: " + activitySet.getType() + "; by: " + activitySet.getCreatedBy());
                LOG.debug("   alreadyCreated: " + alreadyCreated);
            }
            
            if (!alreadyCreated)
            {
                // Populate the ActivitySet
                // Get the ActivitySet type/createdby values (we know these are valid)
                final ActivitySetType ttOM = ActivitySetTypeManager.getInstance(activitySet.getType());
                activitySetOM.setActivitySetType(ttOM);
                if( activitySetCreatedByOM != null ){
                    activitySetOM.setCreatedBy(activitySetCreatedByOM.getUserId());
                }
                else
                {
                	// Anonymous user. better than nothing.
                	try {
						activitySetOM.setCreatedBy(ScarabUserManager.getAnonymousUser().getUserId());
					} catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                }
                activitySetOM.setCreatedDate(activitySet.getCreatedDate().getDate());
                if (activitySetAttachmentOM != null)
                {
                    activitySetAttachmentOM.save();
                    activitySetOM.setAttachment(activitySetAttachmentOM);
                }
                activitySetOM.save();
                if( activitySet.getId() != null){
                    // if id is valid, save for later re-use.
                    activitySetIdMap.put(activitySet.getId(), 
                                         activitySetOM.getPrimaryKey().toString());
                }
            }

            // Determine if this ActivitySet should be marked as the 
            // creation event
            final ActivitySet creationSet = issueOM.getActivitySetRelatedByCreatedTransId();
            if (ActivitySetTypePeer.CREATE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) 
               ||
               (ActivitySetTypePeer.MOVE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) && 
                        (creationSet == null || activitySetOM.getCreatedDate()
                         .before(creationSet.getCreatedDate()))) ) 
            {
                issueOM.setActivitySetRelatedByCreatedTransId(activitySetOM);
                issueOM.save();
            }

/////////////////////////////////////////////////////////////////////////////////  
// Deal with changing user attributes. this code needs to be in this *strange*
// location because we look at the entire activityset in order to determine
// that this is a change user activity set. of course in the future, it would
// be really nice to create an activityset/activiy type that more accurately 
// reflects what type of change this is. so that it is easier to case for. for
// now, we just look at some fingerprints to determine this information. -JSS

            if (activitySet.isChangeUserAttribute())
            {
                final List activities = activitySet.getActivities();
                final XmlActivity activityA = (XmlActivity)activities.get(0);
                final XmlActivity activityB = (XmlActivity)activities.get(1);
                
                final ScarabUser assigneeOM = findUser(activityA.getOldUser());
                final ScarabUser assignerOM = findUser(activityB.getNewUser());

                final Attribute oldAttributeOM = Attribute.getInstance(activityA.getAttribute());

                final AttributeValue oldAttValOM = issueOM.getUserAttributeValue(assigneeOM, oldAttributeOM);
                if (oldAttValOM == null)
                {
                    LOG.error("User '" + assigneeOM.getName() + "' was not previously '" + oldAttributeOM.getName() + "' to the issue!");
                }

                // Get the Attribute associated with the new Activity
                final Attribute newAttributeOM = Attribute.getInstance(activityB.getAttribute());

                issueOM.changeUserAttributeValue(activitySetOM,
                            assigneeOM, 
                            assignerOM, 
                            oldAttValOM,
                            newAttributeOM, null);
                LOG.debug("-------------Updated User AttributeValue------------");
                continue;
            }

/////////////////////////////////////////////////////////////////////////////////  

            // Deal with the activities in the activitySet
            final List activities = activitySet.getActivities();
            LOG.debug("Number of Activities in ActivitySet: " + activities.size());

            final LinkedMap avMap = issueOM.getModuleAttributeValuesMap();
            LOG.debug("Total Module Attribute Values: " + avMap.size());
            for (Iterator itrb = activities.iterator(); itrb.hasNext();)
            {
                final XmlActivity activity = (XmlActivity) itrb.next();
                LOG.debug("Looking at activity id: " + activity.getId());

                // Get the Attribute associated with the Activity
                final Attribute attributeOM = Attribute.getInstance(activity.getAttribute());

                // deal with the activity attachment (if there is one)
                final XmlAttachment activityAttachment = activity.getAttachment();
                Attachment activityAttachmentOM = null;
                if (activityAttachment != null)
                {
                    // look for an existing attachment in the activity
                    // the case is when we have a URL and we create it
                    // and then delete it, the attachment id is still the
                    // same so there is no reason to re-create the attachment
                    // again.
                    final String previousXmlId = activityAttachment.getId();
                    final String previousId = (String)attachmentIdMap.get(previousXmlId);
                    if (previousId == null) 
                    {
                        activityAttachmentOM = createAttachment(issueOM, activityAttachment);
                        activityAttachmentOM.save();
                        attachmentIdMap.put(previousXmlId, activityAttachmentOM.getPrimaryKey().toString());
                        
                        // Special case. After the Attachment object has been 
                        // saved, if the ReconcilePath == true, then assume 
                        // that the fileName is an absolute path to a file and
                        // copy it to the right directory
                        // structure under Scarab's path.
                        if (allowFileAttachments && activityAttachment.getReconcilePath())
                        {
                            try
                            {
                                activityAttachmentOM
                                    .copyFileFromTo(activityAttachment.getFilename(), 
                                                    activityAttachmentOM.getFullPath());
                            } 
                            catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            } 
                            catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                        }
                        LOG.debug("Created Activity Attachment object");
                    }
                    else 
                    {
                        activityAttachmentOM = AttachmentManager
                            .getInstance(previousId);
                        LOG.debug("Found existing Activity Attachment");
                    }
                }
                else
                {
                    LOG.debug("OK- No Attachment in this Activity");
                }

                // deal with null attributes (need to do this before we create the 
                // activity right below because this will create its own activity).
                if (attributeOM.equals(nullAttribute))
                {
                    // add any dependency activities to a list for later processing
                    if (isDependencyActivity(activity))
                    {
                        if (!isDuplicateDependency(activity))
                        {
                            final Object[] obj = {activitySetOM, activity, activityAttachmentOM};
                            allDependencies.add(obj);
                            dependActivitySetId.add(activity.getDependency());
                            LOG.debug("-------------Stored Dependency # " 
                                    + allDependencies.size() + '[' + activity.getDependency() + ']');
                            continue;
                        }
                    }
                    else
                    {
                        // create the activity record.
                        ActivityManager.createTextActivity(issueOM, nullAttribute, activitySetOM, 
                                    ActivityType.getActivityType(activity.getActivityType()), activity.getDescription(), activityAttachmentOM, 
                                    activity.getOldValue(), activity.getNewValue());
        
                        LOG.debug("-------------Saved Null Attribute-------------");
                        continue;
                    }
                }

                // create the activityOM
                createActivity(activity, module, 
                                            issueOM, attributeOM, activitySetOM);

                // check to see if this is a new activity or an update activity
                AttributeValue avalOM = null;
                for (Iterator moduleAttributeValueItr = avMap.mapIterator(); 
                     moduleAttributeValueItr.hasNext() && avalOM == null;)
                {
                    final AttributeValue testAvalOM = (AttributeValue)
                        avMap.get(moduleAttributeValueItr.next());
                    final Attribute avalAttributeOM = testAvalOM.getAttribute();

                    LOG.debug("Checking Attribute match: " + avalAttributeOM.getName() + 
                              " against: " + attributeOM.getName());
                    if (avalAttributeOM.equals(attributeOM))
                    {
                        avalOM = testAvalOM;
                    }
                }

                if (avalOM != null) 
                {
                    final Attribute avalAttributeOM = avalOM.getAttribute();
                    LOG.debug("Attributes match!");
                    AttributeValue avalOM2 = null;
                    if (!activity.isNewActivity())
                    {
                        LOG.debug("Activity is not new.");
                        avalOM2 = AttributeValue.getNewInstance(
                            avalAttributeOM.getAttributeId(), 
                            avalOM.getIssue());
                        avalOM2.setProperties(avalOM);
                    }

                    if (avalAttributeOM.isOptionAttribute())
                    {
                        LOG.debug("We have an Option Attribute: " + 
                                  avalAttributeOM.getName());
                        final AttributeOption newAttributeOptionOM = 
                                AttributeOptionManager.getInstance(
                                         attributeOM, activity.getNewOption(),
                                         issueOM.getModule(),
                                         issueOM.getIssueType());
                        if (activity.isNewActivity())
                        {
                            if (newAttributeOptionOM != null)
                            {
                                avalOM.setOptionId(newAttributeOptionOM.getOptionId());
                                avalOM.startActivitySet(activitySetOM);
                                avalOM.setAttribute(attributeOM);
                                avalOM.save();
                                LOG.debug("-------------Saved Attribute Value-------------");
                            }
                            else
                            {
                                LOG.warn("NewAttributeOptionOM is null for " +
                                         activity.getNewOption());
                            }
                        }
                        else if(newAttributeOptionOM != null)
                        {
                            avalOM2.setOptionId(newAttributeOptionOM.getOptionId());
                            final HashMap map = new HashMap();
                            map.put(avalOM.getAttributeId(), avalOM2);
                            issueOM.setAttributeValues(activitySetOM, map, null, activitySetCreatedByOM);
                            LOG.debug("-------------Saved Option Attribute Change-------------");
                        }
                    }
                    else if (avalAttributeOM.isUserAttribute())
                    {
                        LOG.debug("We have a User Attribute: " 
                                  + avalAttributeOM.getName());
                        if (activity.isNewActivity())
                        {
                            // Don't need to pass in the attachment because
                            // it is already in the activitySetOM.
                            // If we can't get an assignee new-user, then 
                            // use the activity set creator as assignee.
                            ScarabUser assigneeOM = findUser(activity.getNewUser());
                            assigneeOM = (assigneeOM != null)
                                ? assigneeOM: activitySetCreatedByOM;
                            if( assigneeOM != null ){
                                issueOM.assignUser(activitySetOM, 
                                    assigneeOM, null, avalAttributeOM, null);
                            }
                            LOG.debug("-------------Saved User Assign-------------");
                        }
                        else if (activity.isRemoveUserActivity())
                        {
                            // remove a user activity
                            final ScarabUser oldUserOM = findUser(activity.getOldUser());
                            // need to reset the aval because the current one
                            // is marked as new for some reason which causes an
                            // insert and that isn't the right behavior here 
                            // (we want an update)
                            avalOM = null;
                            for (Iterator i = issueOM.getAttributeValues(
                                 avalAttributeOM).iterator(); 
                                 i.hasNext() && avalOM == null;) 
                            {
                                final AttributeValue av = (AttributeValue)i.next();
                                if (oldUserOM.getUserId().equals(av.getUserId())) 
                                {
                                    avalOM = av;
                                }
                            }

                            if (avalOM == null) 
                            {
                                if (LOG.isDebugEnabled()) 
                                {
                                    LOG.debug("Could not find previous AttributeValue assigning " +
                                        (oldUserOM == null ? "NULL" : 
                                        oldUserOM.getUserName()) + 
                                        " to attribute " + 
                                              avalAttributeOM.getName());
                                }                                
                            }
                            else 
                            {
                                // don't need to pass in the attachment because
                                // it is already in the activitySetOM
                                issueOM.deleteUser(activitySetOM, oldUserOM, 
                                    activitySetCreatedByOM, avalOM, null);
                                LOG.debug("-------------Saved User Remove-------------");
                            }
                        }
                    }
                    else if (avalAttributeOM.isTextAttribute() || avalAttributeOM.isIntegerAttribute())
                    {
                        LOG.debug("We have a Text Attribute: " + avalAttributeOM.getName());

                        avalOM.startActivitySet(activitySetOM);
                        avalOM.setAttribute(attributeOM);

                        if (activity.isNewActivity())
                        {
                            avalOM.setValue(activity.getNewValue());
                        }
                        else if (!activity.getNewValue()
                                .equals(avalOM.getValue()))
                        {
                            avalOM2.setValue(activity.getNewValue());
                            avalOM.setProperties(avalOM2);
                        }
                        
                        avalOM.save();
                        LOG.debug("-------------Saved Attribute Value-------------");
                    }
                }
                issueOM.save();
                LOG.debug("-------------Saved Issue-------------");
            }
        }
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Activity createActivity(final XmlActivity activity,  
                                         final XmlModule module,
                                         final Issue issueOM, 
                                         final Attribute attributeOM,
                                         final ActivitySet activitySetOM)
        throws TorqueException, ParseException, ScarabException
    {
        Activity activityOM = null;
        if (getImportTypeCode() == UPDATE_SAME_DB)
        {
            try
            {
                activityOM = ActivityManager.getInstance(activity.getId());
            }
            catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
        }
        else
        {
            activityOM = ActivityManager.getInstance();
        }

        activityOM.setIssue(issueOM);
        activityOM.setAttribute(attributeOM);
        activityOM.setActivityType(ActivityType.OTHER.getCode());
        activityOM.setActivitySet(activitySetOM);
        if (activity.getEndDate() != null)
        {
            activityOM.setEndDate(activity.getEndDate().getDate());
        }

        // Set the attachment for the activity
        Attachment newAttachmentOM = null;
        if (activity.getAttachment() != null)
        {
            newAttachmentOM = createAttachment(issueOM, activity.getAttachment());
            newAttachmentOM.save();
            activityOM.setAttachment(newAttachmentOM);
        }

        LOG.debug("Created New Activity");
        return activityOM;
    }
              
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Attachment createAttachment(final Issue issueOM, 
            final XmlAttachment attachment)
        throws TorqueException, ScarabException, ParseException
    {
        final Attachment attachmentOM = AttachmentManager.getInstance();
        attachmentOM.setIssue(issueOM);
        final AttachmentType type = AttachmentType.getInstance(attachment.getType());
        if (allowFileAttachments || !Attachment.FILE__PK.equals(type.getAttachmentTypeId())) 
        {
            attachmentOM.setName(attachment.getName());
            attachmentOM.setAttachmentType(type);
            attachmentOM.setMimeType(null != attachment.getMimetype()
                    ? attachment.getMimetype()
                    : ComponentLocator.getMimeTypeService().getContentType(attachment.getFilename(), null));
            attachmentOM.setFileName(attachment.getFilename());        
            attachmentOM.setData(attachment.getData());
        }
        else 
        {
            // add a comment that the file will not be imported.  An alternative would be
            // to skip the activity altogether, but we will then need to check that there 
            // are other activities or we need to completely ignore the ActivitySet
            attachmentOM.setName("comment");
            attachmentOM.setTypeId(Attachment.COMMENT__PK);
            attachmentOM.setMimeType("text/plain");
            String text = "File, " + attachment.getFilename() + 
                ", was not imported. The old description follows:\n\n" + attachment.getName();
            final String data = attachment.getData();  // this should be null, but just in case
            if (data != null) 
            {
                text += "\n\n" + data;
            }
            attachmentOM.setData(text);
        }
        
        attachmentOM.setCreatedDate(attachment.getCreatedDate().getDate());
        final ModifiedDate modifiedDate = attachment.getModifiedDate();
        if (modifiedDate != null)
        {
            attachmentOM.setModifiedDate(modifiedDate.getDate());
        }
        final ScarabUser creUser = findUser(attachment.getCreatedBy());
        if (creUser != null)
        {
            attachmentOM.setCreatedBy(creUser.getUserId());
        }

        final String modifiedBy = attachment.getModifiedBy();
        if (modifiedBy != null)
        {
            final ScarabUser modUserOM = findUser(attachment.getModifiedBy());
            if (modUserOM != null)
            {
                attachmentOM.setModifiedBy(modUserOM.getUserId());
            }
        }

        attachmentOM.setDeleted(attachment.getDeleted());
        return attachmentOM;
    }
              
// in java/org/tigris/scarab/util/ScarabUtil.java
private static Date parseDate(String dateString, Localizable dateFormat, Locale locale) 
    throws ParseException
    {
    	Date date;
    	
    	ScarabLocalizationTool l10n = new ScarabLocalizationTool();
        l10n.init(locale);
    	
    	String[] patterns = {
                            l10n.get(dateFormat),
                            ScarabConstants.ISO_DATETIME_PATTERN };
    	date = parseDate(dateString, patterns);
    	return date;
    	
    }
              
// in java/org/tigris/scarab/util/ScarabUtil.java
private static Date parseDate(String s, String[] patterns)
        throws ParseException
    {
        if (s == null) 
        {
            throw new ParseException("Input string was null", -1);
        }

        SimpleDateFormat formatter = new SimpleDateFormat();

        for (int i = 0; i < patterns.length; i++) 
        {
        	Date date = null;
        	formatter.applyPattern(patterns[i]);
            try
            {
            	date = formatter.parse(s);
            }
            catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }            
            if (date != null) 
            {
                return date;
            }
        }
        
        throw new ParseException("Date could not be parsed with any"
                                 + " of the provided date patterns.", -1);
    }
              
// in java/org/tigris/scarab/util/ScarabUtil.java
public static Date parseDate(String dateString, boolean addTwentyFourHours, Locale locale)
        throws ParseException
    {
        Date date = null;
        if (dateString != null) 
        {
            Matcher m = RELATIVE_DATE_PATTERN.matcher(dateString);
        	if(m.matches())
        	{
                date = new Date();

        		    String dateDifference = m.group(3);
        		    String sign = m.group(2);
        		    if(dateDifference!=null)
        		{
                    long hours = Long.parseLong(dateDifference);  
                    if (sign.equals("-")) hours = hours * -1;
                    date.setTime(date.getTime() + hours * 3600000 );
        		}
        	}
            else if (dateString.indexOf(':') == -1)
            {
                date = parseDate(dateString, L10NKeySet.ShortDatePattern, locale);
                
                if (addTwentyFourHours) 
                {                
                    date.setTime(date.getTime() + 86399999);
                }
            }
            else
            {
                date = parseDate(dateString, L10NKeySet.ShortDateTimePattern, locale);        
            }
        }
        
        return date;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
public Date parseDate(String dateString, boolean addTwentyFourHours)
        throws ParseException
    {
        Date date = null;
        if (dateString != null) 
        {
            Matcher m = RELATIVE_DATE_PATTERN.matcher(dateString);
        	if(m.matches())
        	{
                date = new Date();

        		    String dateDifference = m.group(3);
        		    String sign = m.group(2);
        		    if(dateDifference!=null)
        		{
                    long hours = Long.parseLong(dateDifference);  
                    if (sign.equals("-")) hours = hours * -1;
                    date.setTime(date.getTime() + hours * 3600000 );
        		}
        	}
            else if (dateString.indexOf(':') == -1)
            {
                date = parseDate(dateString, L10NKeySet.ShortDatePattern);
                
                if (addTwentyFourHours) 
                {                
                    date.setTime(date.getTime() + 86399999);
                }
            }
            else
            {
                date = parseDate(dateString, L10NKeySet.ShortDateTimePattern);        
            }
        }
        
        return date;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Date parseDate(String dateString, Localizable dateFormat) 
        throws ParseException
    {
        Date date;
        String[] patterns = {
            L10N.get(dateFormat),
            ScarabConstants.ISO_DATETIME_PATTERN };
        date = parseDate(dateString, patterns);
        return date;
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Date parseDate(String s, String[] patterns)
        throws ParseException
    {
        if (s == null) 
        {
            throw new ParseException("Input string was null", -1);
        }

        if (formatter == null) 
        {
            formatter = new SimpleDateFormat();
        }
        
        for (int i = 0; i < patterns.length; i++) 
        {
        	Date date = null;
        	formatter.applyPattern(patterns[i]);
            try
            {
            	date = formatter.parse(s);
            }
            catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }            
            if (date != null) 
            {
                return date;
            }
        }
        
        throw new ParseException("Date could not be parsed with any"
                                 + " of the provided date patterns.", -1);
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addDateRangeCriteria( Criteria crit, String column, 
                                  String minDateStr, String maxDateStr)
        throws java.text.ParseException
    {        
        Date minDate = parseDate(minDateStr, false);
        Date maxDate = parseDate(maxDateStr, true);
    
        if(minDate!=null)
        {
            crit.and(column, minDate, Criteria.GREATER_EQUAL);
        }
        if(maxDate!=null)
        {
            crit.and(column, maxDate, Criteria.LESS_EQUAL);
        }
    }
              
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addTransDateRange(Criteria crit, 
                                 String alias,
                                 String baseColumn,
                                 String minDateStr, String maxDateStr)
        throws java.text.ParseException
    {
        if(minDateStr != null || maxDateStr != null)
        {
            crit.addAlias(alias, ActivitySetPeer.TABLE_NAME);
            crit.addJoin( 
                baseColumn, 
                useAlias(alias,ActivitySetPeer.TRANSACTION_ID), 
                Criteria.INNER_JOIN 
            );
            addDateRangeCriteria(crit,useAlias(alias, ActivitySetPeer.CREATED_DATE),
                                 minDateStr,maxDateStr);    
        } 
    }
(Lib) TurbineSecurityException 6 
              
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
public void delete(final ScarabUser user) throws TorqueException, TurbineSecurityException 
    { 
        boolean hasPermission = true;
        if (getModule() != null)
        {
            hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,getModule());
        }
        else //getModule() is null for X Project queries, so get the modules from the MIT List
        {
            final List moduleList = user.getCurrentMITList().getModules();
            for (Iterator iter = moduleList.iterator(); iter.hasNext(); )
            {
                hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,(Module)iter.next());
                if (!hasPermission)
                {
                    break;
                }
            }
        }
        if (hasPermission)
        {
            final Criteria c = new Criteria()
                .add(RModuleUserAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleUserAttributePeer.LIST_ID, getListId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleUserAttributePeer.doDelete(c);
        }
        else
        {
            throw new TurbineSecurityException(ScarabConstants.NO_PERMISSION_MESSAGE); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void remove()
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void rename(String name)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void grant(User user, RoleSet roleSet)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void revoke(User user, Role role)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void revoke(User user, RoleSet roleSet)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
0 13
              
// in java/org/tigris/scarab/om/MITList.java
public List getAllRModuleUserAttributes() 
    throws TorqueException, DataSetException, TurbineSecurityException
    {
        List rmuas = getSavedRMUAs();
        return rmuas;
    }
              
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleUserAttributes() 
        throws TorqueException, DataSetException, TurbineSecurityException
    {
        final List matchingRMUAs = new ArrayList();
        List rmuas = getSavedRMUAs();
        Iterator i = rmuas.iterator();
        final ScarabUser user = getScarabUser();
        while (i.hasNext())
        {
            final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
            final Attribute att = rmua.getAttribute();
            if (isCommon(att, false))
            {
                matchingRMUAs.add(rmua);
            }
        }

        // None of the saved RMUAs are common for these pairs
        // Delete them and seek new ones.
        if (matchingRMUAs.isEmpty())
        {
            i = rmuas.iterator();
            while (i.hasNext())
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                rmua.delete(user);
            }
            final int sizeGoal = 3;
            int moreAttributes = sizeGoal;

            // First try saved RMUAs for first module-issuetype pair
            final MITListItem item = getFirstItem();
            final Module module = getModule(item);
            final IssueType issueType = item.getIssueType();
            rmuas = user.getRModuleUserAttributes(module, issueType);
            // Next try default RMUAs for first module-issuetype pair
            if (rmuas.isEmpty())
            {
                rmuas = module.getDefaultRModuleUserAttributes(issueType);
            }

            // Loop through these and if find common ones, save the RMUAs
            i = rmuas.iterator();
            while (i.hasNext() && moreAttributes > 0)
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                final Attribute att = rmua.getAttribute();
                if (isCommon(att, false) && !matchingRMUAs.contains(rmua))
                {
                    final RModuleUserAttribute newRmua =
                        getNewRModuleUserAttribute(att);
                    newRmua.setOrder(1);
                    newRmua.save();
                    matchingRMUAs.add(rmua);
                    moreAttributes--;
                }
            }

            // if nothing better, go with random common attributes
            moreAttributes = sizeGoal - matchingRMUAs.size();
            if (moreAttributes > 0)
            {
                Iterator attributes = getCommonAttributes(false).iterator();
                int k = 1;
                while (attributes.hasNext() && moreAttributes > 0)
                {
                    Attribute att = (Attribute) attributes.next();
                    boolean isInList = false;
                    i = matchingRMUAs.iterator();
                    while (i.hasNext())
                    {
                        RModuleUserAttribute rmua =
                            (RModuleUserAttribute) i.next();
                        if (rmua.getAttribute().equals(att))
                        {
                            isInList = true;
                            break;
                        }
                    }
                    if (!isInList)
                    {
                        RModuleUserAttribute rmua =
                            getNewRModuleUserAttribute(att);
                        rmua.setOrder(k++);
                        rmua.save();
                        matchingRMUAs.add(rmua);
                        moreAttributes--;
                    }
                }
            }
        }

        return matchingRMUAs;
    }
              
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
public void delete(final ScarabUser user) throws TorqueException, TurbineSecurityException 
    { 
        boolean hasPermission = true;
        if (getModule() != null)
        {
            hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,getModule());
        }
        else //getModule() is null for X Project queries, so get the modules from the MIT List
        {
            final List moduleList = user.getCurrentMITList().getModules();
            for (Iterator iter = moduleList.iterator(); iter.hasNext(); )
            {
                hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,(Module)iter.next());
                if (!hasPermission)
                {
                    break;
                }
            }
        }
        if (hasPermission)
        {
            final Criteria c = new Criteria()
                .add(RModuleUserAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleUserAttributePeer.LIST_ID, getListId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleUserAttributePeer.doDelete(c);
        }
        else
        {
            throw new TurbineSecurityException(ScarabConstants.NO_PERMISSION_MESSAGE); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void remove()
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void rename(String name)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void grant(User user, Role role)
        throws TurbineSecurityException
    {
        TurbineSecurity.grant(user,this,role);

        // TODO: Needs to be refactored into the Users system?
        ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.GET_ACL);
        ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable)role, this);
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void grant(User user, RoleSet roleSet)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void revoke(User user, Role role)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabModule.java
public void revoke(User user, RoleSet roleSet)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
protected void deleteRModuleUserAttribute(final RModuleUserAttribute rmua)
                throws TorqueException, TurbineSecurityException
            {
                privateDeleteRModuleUserAttribute(rmua);
            }
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private void privateDeleteRModuleUserAttribute(final RModuleUserAttribute rmua)
        throws TorqueException, TurbineSecurityException
    {
        rmua.delete(this);
    }
              
// in java/org/tigris/scarab/feeds/QueryFeed.java
public SyndFeed getFeed() throws Exception, TorqueException, DataSetException, TurbineSecurityException
    {
        SyndFeed feed = new SyndFeedImpl();
        feed.setTitle(query.getName());
        String link = scarabLink.setAction("Search").addPathInfo("go",query.getQueryId()).toString();
        feed.setLink(link);
        feed.setDescription(query.getDescription());
        List entries = new ArrayList();
        for(Iterator i = results.iterator(); i.hasNext();)
        {
            SyndEntry entry = new SyndEntryImpl();
            SyndContent description = new SyndContentImpl();
            QueryResult queryResult = (QueryResult)i.next();
            String title = queryResult.getUniqueId();
            entry.setTitle(title);
            
            Issue issue = IssueManager.getInstance(Long.valueOf(queryResult.getIssueId()));

            link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
            entry.setLink(link);

            Date publishedDate = null;
            if(issue.getModifiedDate()!= null){
                publishedDate = issue.getModifiedDate();
            }
            else {
                publishedDate = issue.getCreatedDate();
            }
            entry.setPublishedDate(publishedDate);

            description = new SyndContentImpl();
            description.setType("text/html");
            String desc = "";
            Iterator avIteratorCSV = queryResult.getAttributeValuesAsCSV().iterator();
            Iterator avIterator = query.getMITList().getAllRModuleUserAttributes().iterator();
            while (avIterator.hasNext())
            {
                String value = (String)avIteratorCSV.next();
                RModuleUserAttribute av = (RModuleUserAttribute)avIterator.next();
                desc = desc + "<b>" + av.getAttribute().getName()+":</b>" + value +"<br/>";
            }
            description.setValue(ScarabUtil.filterNonXml(desc));

            entry.setDescription(description);
            entries.add(entry);
        }
        feed.setEntries(entries);
        feed.setFeedType(format);
        return feed;
    }
              
// in java/org/tigris/scarab/actions/ScarabAccessController.java
public void doPerform( RunData data )
        throws TurbineSecurityException
    {
        User user = data.getUser();

        if (user.hasLoggedIn() && user.isConfirmed())
        {
            AccessControlList acl = (AccessControlList)
                    data.getSession().getAttribute(
                            AccessControlList.SESSION_KEY);

            if (acl == null)
            {
                acl = TurbineSecurity.getACL(user);
                data.getSession().setAttribute(
                        AccessControlList.SESSION_KEY, acl);
            }
            data.setACL(acl);
        }
    }
(Lib) NoSuchElementException 4 
              
// in java/org/tigris/scarab/util/IteratorWithSize.java
public Object next()
    {
        throw new NoSuchElementException("This is an empty list."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/util/WindowIterator.java
public Object next()
    {
        if (hasNext()) 
        {
            hasNext = null;
            return window[bsize];
        }
        else 
        {
            throw new NoSuchElementException("Iterator is exhausted"); //EXCEPTION
        }
    }
              
// in java/org/tigris/scarab/util/WindowIterator.java
public Object next()
    {
        throw new NoSuchElementException("This is an empty list."); //EXCEPTION
    }
              
// in java/org/tigris/scarab/util/WindowIterator.java
public Object get(int i)
    {
        throw new NoSuchElementException("This is an empty list."); //EXCEPTION
    }
0 0
(Lib) EmailException 3 
              
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
public String send()
        throws EmailException
    {
        context.put("mail", this);

        String htmlbody = "";
        String textbody = "";

        // Create MessageBody from template:
        try
        {
            if (htmlTemplate != null)
            {
                htmlbody = handleRequest(htmlTemplate, true);
            }
            if (textTemplate != null)
            {
                textbody = handleRequest(textTemplate, false);
            }                    
        }
        catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }

        // Set appropriate Message body:
        try
        {
            if (StringUtils.isNotEmpty(htmlbody) && StringUtils.isNotEmpty(textbody))
            {
                // We have both plain text and HTML message bodys
                setHtmlMsg(htmlbody); 
                setTextMsg(textbody); 
            }
            else if (StringUtils.isEmpty(htmlbody)) 
            {
                // We have only a text body.
                setTextMsg(textbody);
                /* Note that we don't use setMsg() because that would put the plain
                 * text into a <html><pre>[plain text]</pre></html> stansa in the
                 * HTML part. Not particularly useful. Worse, it also defeats any 
                 * hyperlinks in the message.
                 */
            }
            else
            {
                // We have only a HTML message. Recipients with a text-only client
                // won't like this.
                setHtmlMsg(htmlbody); 
            }
        }
        catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }


        // Send message to recipients:
        String mimeMessageId = null;
        try
        {
            mimeMessageId = super.send();
            logSend();
        }
        catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
        
        return mimeMessageId;
    }
3
              
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }
              
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }
              
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
1
              
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
public String send()
        throws EmailException
    {
        context.put("mail", this);

        String htmlbody = "";
        String textbody = "";

        // Create MessageBody from template:
        try
        {
            if (htmlTemplate != null)
            {
                htmlbody = handleRequest(htmlTemplate, true);
            }
            if (textTemplate != null)
            {
                textbody = handleRequest(textTemplate, false);
            }                    
        }
        catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }

        // Set appropriate Message body:
        try
        {
            if (StringUtils.isNotEmpty(htmlbody) && StringUtils.isNotEmpty(textbody))
            {
                // We have both plain text and HTML message bodys
                setHtmlMsg(htmlbody); 
                setTextMsg(textbody); 
            }
            else if (StringUtils.isEmpty(htmlbody)) 
            {
                // We have only a text body.
                setTextMsg(textbody);
                /* Note that we don't use setMsg() because that would put the plain
                 * text into a <html><pre>[plain text]</pre></html> stansa in the
                 * HTML part. Not particularly useful. Worse, it also defeats any 
                 * hyperlinks in the message.
                 */
            }
            else
            {
                // We have only a HTML message. Recipients with a text-only client
                // won't like this.
                setHtmlMsg(htmlbody); 
            }
        }
        catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }


        // Send message to recipients:
        String mimeMessageId = null;
        try
        {
            mimeMessageId = super.send();
            logSend();
        }
        catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
        
        return mimeMessageId;
    }
(Lib) IndexOutOfBoundsException 3 
              
// in java/org/tigris/scarab/search/CachedResultList.java
public Object get(int index)
	{
	    if(index>query.totalRowCount())
	    {
	        throw new IndexOutOfBoundsException();
	    }
	    else if(index>query.cachedRowCount())
	    {
	        query.cacheAll();
		    if(index>query.cachedRowCount())
		    	index = query.cachedRowCount();
	    }
	    return query.getCachedRows().get(index);
	}
              
// in java/org/tigris/scarab/reports/ReportTableModel.java
public Object getValueAt(int row, int column)
        throws Exception
    {
        if (row < 0 || row >= getRowCount())
        {
            throw new IndexOutOfBoundsException("Row index was " + row); //EXCEPTION
        }
        
        if (column < 0 || column >= getColumnCount()) 
        {
            throw new IndexOutOfBoundsException("Column index was " + column); //EXCEPTION
        }

        Object contents = ReportManager.getMethodResult().get(this,GET_VALUE_AT,new Integer(row),new Integer(column));

        if(contents==null){
        
            //could use a categories list to make this simpler
            if (columnHeadings != null && columnHeadings.size() == 1 && 
                    ((ReportHeading)columnHeadings.get(0)).get(0) instanceof ReportDate) 
            {
                Date date = ((ReportDate) ((ReportHeading) columnHeadings.get(0))
                             .get(column)).dateValue();
                if (date.getTime() <= System.currentTimeMillis())
                {
                    contents = new Integer(getIssueCount(getRowDataArray(row),
                                                         date));
                }
                else
                {
                    // Dates in the future are not applicable to reporting.
                    contents = "";
                }
            }
            else if (rowHeadings != null && rowHeadings.size() == 1 && 
                     ((ReportHeading)rowHeadings.get(0)).get(0) instanceof ReportDate)
            {
                Date date = ((ReportDate)((ReportHeading)rowHeadings.get(0))
                             .get(row)).dateValue();
                if (date.getTime() <= System.currentTimeMillis())
                {
                   contents = new Integer(getIssueCount(
                        getColumnDataArray(column), date));
                }
                else
                {
                   // Dates in the future are not applicable to reporting.
                   contents = "";
                }
            }
            else if (columnHeadings != null && columnHeadings.size() == 1 && 
                    ((ReportHeading)columnHeadings.get(0)).get(0) instanceof ReportDateRange) 
            {
            	Date minDate =((ReportDateRange)((ReportHeading)columnHeadings.get(0))
                        .get(column)).getMinDate(searcher.getLocale());
            	
            	Date maxDate = ((ReportDateRange)((ReportHeading)columnHeadings.get(0))
                        .get(column)).getMaxDate(searcher.getLocale());
            	
            	contents = new Integer(getIssueCountRange(
                        getRowDataArray(row), minDate, maxDate));
            	
            }
            else if (rowHeadings != null && rowHeadings.size() == 1 && 
                     ((ReportHeading)rowHeadings.get(0)).get(0) instanceof ReportDateRange)
            {
            	Date minDate = ((ReportDateRange)((ReportHeading)rowHeadings.get(0))
                        .get(row)).getMinDate(searcher.getLocale());
            	
            	Date maxDate = ((ReportDateRange)((ReportHeading)rowHeadings.get(0))
                        .get(row)).getMaxDate(searcher.getLocale());
            	
            	contents = new Integer(getIssueCountRange(
                        getColumnDataArray(column), minDate, maxDate));
            }
            else
            {
                contents = new Integer(getIssueCount(
                    getRowDataArray(row), getColumnDataArray(column), date)); 
            }

            ReportManager.getMethodResult().put(contents,this,GET_VALUE_AT,new Integer(row),new Integer(column));
        }

        return contents;
    }
0 0
(Lib) TurbineException 3 
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        
        try
        {
            // Check, whether password is expired 
            if(user.isPasswordExpired())
            {
                // Under no conditions an expired password will be
                // accepted. The request is always forwarded to the
                // password change mask until the password has been reset. [HD]
                data.setTarget("ChangePassword.vm");
                data.save();
                context.invokeNext(data);
                return;
            }
            adjustCurrentModule(user, data);
            adjustCurrentIssueType(user, data);
        }
        catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }

        // set the thread key 
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.THREAD_QUERY_KEY);
        if (key != null) 
        {
            user.setThreadKey(new Integer(key));
        }
        else
        {
            user.setThreadKey(null);
        }
        
        // remove any report that was aborted
        String reportKey = parameters.getString(ScarabConstants.REMOVE_CURRENT_REPORT);
        if (reportKey != null && reportKey.length() > 0)
        {
            user.setCurrentReport(reportKey, null);
        }

        // remove the current module/issuetype list, if needed
        String removeMitKey = 
            parameters.getString(ScarabConstants.REMOVE_CURRENT_MITLIST_QKEY);
        String target = data.getTarget();
        boolean xmitScreen =XMIT_SCREENS.containsKey(target); 
        if (removeMitKey != null 
            || !xmitScreen)
        {
            Log.get().debug("xmit list set to null");
            user.setCurrentMITList(null);
        }

        // override the current module/issuetype list if one is given
        // in the url.
        String mitid = parameters.getString(ScarabConstants.CURRENT_MITLIST_ID);
        if (mitid != null) 
        {
            MITList mitList = null;
            try
            {
                // FIXME: no getInstance(Integer)
                mitList = MITListManager.getInstance(new NumberKey(mitid));
                user.setCurrentMITList(mitList);
                mitList.setScarabUser(user);
            }
            catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentModule(ScarabUser user, RunData data)
        throws TurbineException, Exception
    {
        Module module = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_MODULE);
        if (key != null) 
        {
            try
            {
                module = ModuleManager.getInstance(new Integer(key));
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else if (parameters.getString("id") != null) 
        {
            try  
            {
                module = IssueManager.getIssueById(parameters.getString("id")).getModule();
                parameters.setString(ScarabConstants.CURRENT_MODULE, 
                             module.getQueryKey());
            }
            catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
        }
        if(module!=null)
        {
            user.setCurrentModule(module);
        }
    }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentIssueType(ScarabUser user, RunData data)
        throws TurbineException
    {
        IssueType issueType = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_ISSUE_TYPE);
        if (key != null && key.length() > 0)
        {
            try
            {
                issueType = IssueTypeManager.getInstance(new Integer(key));
                if (Log.get().isDebugEnabled()) 
                {
                    Log.get().debug("setting issue type: " + 
                         issueType.getName() + " based on curit");        
                }
            }
            catch (NumberFormatException noIssueType)
            {
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else 
        {
            String templateId = data.getParameters().getString("templateId");
            if (templateId != null && templateId.length() > 0) 
            {
                try
                {
                    IssueType templateType = IssueManager.getInstance(
                        new Long(templateId)).getIssueType();
                    issueType = templateType.getIssueTypeForTemplateType();
                    parameters.setString(ScarabConstants.CURRENT_ISSUE_TYPE,
                                         issueType.getQueryKey());
                    if (Log.get().isDebugEnabled()) 
                    {
                        Log.get().debug("setting issue type: " + 
                            issueType.getName() + " based on template");
                    }
                }
                catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
            }
        }
        
        if(issueType != null)
        {
            user.setCurrentIssueType(issueType);
        }

    }
3
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
12
              
// in java/org/tigris/scarab/pipeline/ResetCacheValve.java
public final void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // clear the short-term cache
        ScarabCache.clear();

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
              
// in java/org/tigris/scarab/pipeline/AnonymousLoginValve.java
public void invoke(RunData data, ValveContext context) throws IOException, TurbineException
    {
        String target = data.getTarget();
        
        // Only try this if accessing an authenticated page:
        if (!nonAnonymousTargets.contains(target) && target.indexOf("help,") == -1)
        {
            ScarabUser user = (ScarabUser)data.getUserFromSession();
            // If there's no user, we will try login:

            if (null == user || user.getUserId() == null || !user.hasLoggedIn())
            {
                boolean isLoggedIn = false;
                String username   = data.getParameters().get("userid");
                // Maybe a User has been provided in the parameter list ?    
                if(username != null)
                {
                    String password = data.getParameters().get("password");
                    final ScarabRequestTool scarabR = null;
                    try
                    {
                        // Try logging in. Note No ScarabRequestTool available here,
                        // so no screen action can be prepared here.
                        isLoggedIn = Login.authentifyWithCredentials(data, scarabR, username, password);
                    }
                    catch(Exception e)
                    {
                        // login failed (user unknown, not confirmed, wrong password, ...) no action taken here
                        // Maybe even anonymous login should be forbidden now ?
                        // See below
                    }
                }

                // We were not able to log in an authenticated user (as possibly tried above) but anonymous login is enabled
                if(!isLoggedIn && anonymousAccessAllowed)
                {
                    // So perform anonymous login here
                    Login.anonymousLogin(data);
                }
                
            }
        }
        context.invokeNext(data);        
    }
              
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve22.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // if we are forcing a particular charset, use it.  Hopefully
        // client has encoded for this default. This is the same 
        // property that will force the charset in our responses.
        String encoding = REQUIRED_CHARSET;   

        if (encoding == null) 
        {
            // guess the charset from the client's headers
            encoding = ComponentLocator.getMimeTypeService().getCharSet(data.getLocale());
        }

        // if the charset was specified in the configuration or the charset
        // map contained a value for the locale, set it, otherwise leave
        // it as the servlet engine has set it.
        if (encoding != null) 
        {
            // data.getRequest().setCharacterEncoding(encoding);
            data.setCharSet(encoding);
        }
        
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
              
// in java/org/tigris/scarab/pipeline/DetermineTargetValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ParameterParser parameters = data.getParameters();
        if (! data.hasTarget())
        {
            String target = parameters.getString("template");
            String query  = parameters.getString("query");
            if(query==null)
            {
                query = parameters.getString("queryId");
            }

            if (query != null && getEventKey(parameters)==null)
            {
                parameters.setString("eventSubmit_doSelectquery", "foo");
                // Allows short link to public/personal queries
                // $scarabRoot/issues/query/<queryId>/curmodule/<moduleId>                
                if (target == null) target="IssueList.vm";
                data.setTarget(target);
                if (parameters.getString("tqk")      == null) parameters.setString("tqk", ""+0);
                if (parameters.getString("action")   == null) data.setAction("Search");
                if (parameters.getString("go")       == null) parameters.setString("go",query);
            }
            else if (target != null)
            {
                data.setTarget(target);
                Log.get().debug("Set target from request parameter");
            }
            else if (parameters.getString("id") != null)
            {
                // Allows short link to issue
                // $scarabRoot/issues/id/<issueId>
                data.setTarget("ViewIssue.vm");
            }
            else
            {
                //data.getResponse().sendError(404);
                //return;
                ScarabUser user = (ScarabUser)data.getUserFromSession();
                if(user!= null && user.getUserId() != null && user.getUserId().longValue() > 0)
                {
                    ScarabRequestTool scarabR = ((ScarabRequestTool)Module.getTemplateContext(data)
                            .get(ScarabConstants.SCARAB_REQUEST_TOOL));
                    org.tigris.scarab.om.Module module = scarabR.getCurrentModule();
                    
                    try
                    {
                        if(module != null)
                        {
                            target = user.getHomePage(module);
                        }
                        else
                        {
                            target = user.getHomePage();
                        }
                    }
                    catch (TorqueException e)
                    {
                        target = null;
                    }
                }
                if(target == null)
                {
                    target = Turbine.getConfiguration().getString(
                            Turbine.TEMPLATE_HOMEPAGE);                    
                }
                data.setTarget(target);
                Log.get().debug("Set target to ["+target+"]");

            }
        }
        
        if (Log.get().isDebugEnabled())
        {
            Log.get().debug("Target is now: " + data.getTarget());
        }

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
              
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // if we are forcing a particular charset, use it.  Hopefully
        // client has encoded for this default. This is the same 
        // property that will force the charset in our responses.
        String encoding = REQUIRED_CHARSET;   

        if (encoding == null) 
        {
            // guess the charset from the client's headers
            encoding = ComponentLocator.getMimeTypeService().getCharSet(data.getLocale());
        }

        // if the charset was specified in the configuration or the charset
        // map contained a value for the locale, set it, otherwise leave
        // it as the servlet engine has set it.
        if (encoding != null) 
        {
            data.getRequest().setCharacterEncoding(encoding);
            data.setCharSet(encoding);
        }
        
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
              
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        if (DEBUG) 
        {
            Long start = (Long)data.getRequest().getAttribute(KEY);
            if (start == null) 
            {
                try 
                {
                    data.getResponse().setBufferSize(10000000);
                }
                catch (Exception e)
                {
                    LOG.debug("Could not set high buffer size so client may " +
                              "affect timing results.");
                }
                ((ScarabRequestTool)Module.getTemplateContext(data)
                    .get("scarabR")).startTimer();
                data.getRequest()
                    .setAttribute(KEY, new Long(System.currentTimeMillis()));
            }
            else
            {
                String s = "Action=" + data.getAction() + " and template=" + 
                    data.getTarget() + " took: " + 
                    (System.currentTimeMillis() - start.longValue()) + " ms";
                LOG.debug(s);
                try 
                {
                    data.getResponse().getWriter().println(s);        
                }
                catch (Exception ignore)
                {
                    // maybe this was a binary response?
                    // we still logged it, so ignore
                }
            }
        }
            
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
              
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ScarabUser user = (ScarabUser) data.getUser();

        // Ensure we only deal with exsiting users
        if (user != null && user.getUserId() != null)
        {
            try
            {
                String acceptLanguage = LocalizationService.ACCEPT_LANGUAGE;
                HttpServletRequest request = data.getRequest();
                String browserLocaleAsString =
                    request.getHeader(acceptLanguage);

                Locale userLocale = user.getLocale();
                Locale browserLocale =
                    Localization.getLocale(browserLocaleAsString);

                if (!userLocale.equals(browserLocale))
                {
                    storePreferredLocale(user, browserLocaleAsString);
                }
            }
            catch (Exception e)
            {
                LOG.warn(
                    "Could not set locale info for user ["
                        + user.getName()
                        + "]");
            }
        }
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        
        try
        {
            // Check, whether password is expired 
            if(user.isPasswordExpired())
            {
                // Under no conditions an expired password will be
                // accepted. The request is always forwarded to the
                // password change mask until the password has been reset. [HD]
                data.setTarget("ChangePassword.vm");
                data.save();
                context.invokeNext(data);
                return;
            }
            adjustCurrentModule(user, data);
            adjustCurrentIssueType(user, data);
        }
        catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }

        // set the thread key 
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.THREAD_QUERY_KEY);
        if (key != null) 
        {
            user.setThreadKey(new Integer(key));
        }
        else
        {
            user.setThreadKey(null);
        }
        
        // remove any report that was aborted
        String reportKey = parameters.getString(ScarabConstants.REMOVE_CURRENT_REPORT);
        if (reportKey != null && reportKey.length() > 0)
        {
            user.setCurrentReport(reportKey, null);
        }

        // remove the current module/issuetype list, if needed
        String removeMitKey = 
            parameters.getString(ScarabConstants.REMOVE_CURRENT_MITLIST_QKEY);
        String target = data.getTarget();
        boolean xmitScreen =XMIT_SCREENS.containsKey(target); 
        if (removeMitKey != null 
            || !xmitScreen)
        {
            Log.get().debug("xmit list set to null");
            user.setCurrentMITList(null);
        }

        // override the current module/issuetype list if one is given
        // in the url.
        String mitid = parameters.getString(ScarabConstants.CURRENT_MITLIST_ID);
        if (mitid != null) 
        {
            MITList mitList = null;
            try
            {
                // FIXME: no getInstance(Integer)
                mitList = MITListManager.getInstance(new NumberKey(mitid));
                user.setCurrentMITList(mitList);
                mitList.setScarabUser(user);
            }
            catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentModule(ScarabUser user, RunData data)
        throws TurbineException, Exception
    {
        Module module = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_MODULE);
        if (key != null) 
        {
            try
            {
                module = ModuleManager.getInstance(new Integer(key));
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else if (parameters.getString("id") != null) 
        {
            try  
            {
                module = IssueManager.getIssueById(parameters.getString("id")).getModule();
                parameters.setString(ScarabConstants.CURRENT_MODULE, 
                             module.getQueryKey());
            }
            catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
        }
        if(module!=null)
        {
            user.setCurrentModule(module);
        }
    }
              
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentIssueType(ScarabUser user, RunData data)
        throws TurbineException
    {
        IssueType issueType = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_ISSUE_TYPE);
        if (key != null && key.length() > 0)
        {
            try
            {
                issueType = IssueTypeManager.getInstance(new Integer(key));
                if (Log.get().isDebugEnabled()) 
                {
                    Log.get().debug("setting issue type: " + 
                         issueType.getName() + " based on curit");        
                }
            }
            catch (NumberFormatException noIssueType)
            {
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else 
        {
            String templateId = data.getParameters().getString("templateId");
            if (templateId != null && templateId.length() > 0) 
            {
                try
                {
                    IssueType templateType = IssueManager.getInstance(
                        new Long(templateId)).getIssueType();
                    issueType = templateType.getIssueTypeForTemplateType();
                    parameters.setString(ScarabConstants.CURRENT_ISSUE_TYPE,
                                         issueType.getQueryKey());
                    if (Log.get().isDebugEnabled()) 
                    {
                        Log.get().debug("setting issue type: " + 
                            issueType.getName() + " based on template");
                    }
                }
                catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
            }
        }
        
        if(issueType != null)
        {
            user.setCurrentIssueType(issueType);
        }

    }
              
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
public void invoke(RunData data, ValveContext context) throws IOException, TurbineException
    {
        try
        {
    	   if (bNTLMActive &&
                   (
                   ((null == data.getUserFromSession() || data.getUserFromSession().getUserName().trim().length()==0) && null == data.getUser())
                   || ((ScarabUser)data.getUserFromSession()).isUserAnonymous()
                   )
                   && ( !data.getAction().equals("Logout")
                           && !data.getAction().equals("Login")
                           && !data.getTarget().equals("Register.vm")
                           && !data.getTarget().equals("ForgotPassword.vm")
                    ))
            {
                authenticateNtlm(data);
            }
        }
        catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
    	   context.invokeNext(data);       
    }
              
// in java/org/tigris/scarab/pipeline/SetInfoMessageValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ((ScarabRequestTool)Module.getTemplateContext(data)
            .get(ScarabConstants.SCARAB_REQUEST_TOOL)).setInfoMessage(message);

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
(Lib) ArrayIndexOutOfBoundsException 2 
              
// in java/org/tigris/scarab/util/WindowIterator.java
public Object get(int i)
    {
        if (i < 0 && (-1 * i) > bsize) 
        {
            throw new ArrayIndexOutOfBoundsException("window was only defined "
                + bsize + " in the negative direction. Argument was " + i); //EXCEPTION
        }

        if (i > 0 && i > fsize) 
        {
            throw new ArrayIndexOutOfBoundsException("window was only defined "
                + fsize + " in the positive direction. Argument was " + i); //EXCEPTION
        }
        
        return window[bsize + i];
    }
0 0
(Lib) NullPointerException 2 
              
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
public static RModuleIssueType getInstance(String key)
        throws TorqueException
    {
        if (key == null) 
        {
            throw new NullPointerException(
                "Cannot request a RModuleIssueType using a null key."); //EXCEPTION
        }
        int colonPos = key.indexOf(':');
        if (colonPos == -1) 
        {
            throw new IllegalArgumentException(
                "RModuleIssueType keys must be of the form N1:N2, not " + key); //EXCEPTION
        }
        // { module_id, issue_type_id } 
        SimpleKey[] keyArray = { new NumberKey(key.substring(1, colonPos)), 
            new NumberKey(key.substring(colonPos+2, key.length()-1)) 
            };
        return getInstance(new ComboKey(keyArray));
    }
              
// in java/org/tigris/scarab/reports/ReportTableModel.java
private void addOptionOrGroup(int alias, Object optionOrGroup, 
                                  Date minDate, Date maxDate, Criteria crit)
    {
        if (optionOrGroup == null) 
        {
            throw new NullPointerException("cell definition cannot contain nulls"); //EXCEPTION
        }

        String a = "a"+alias;
        String t = "t"+alias;
        // there is some redundancy here, but over specifying the joins usually
        // allows the query optimizer to obtain a better optimization
        crit.addJoin(a + '.' + ACT_ISSUE_ID, IssuePeer.ISSUE_ID);
        for (int i=alias-1; i>=0; i--) 
        {
            crit.addJoin("a"+i+'.'+ACT_ISSUE_ID, a+'.'+ACT_ISSUE_ID);
        }
        crit.addAlias("a"+alias, ActivityPeer.TABLE_NAME);
        crit.addAlias("t"+alias, ActivitySetPeer.TABLE_NAME);
        
        crit.addJoin(a+"."+ACT_TRANSACTION_ID, t+'.'+TRAN_TRANSACTION_ID);
        
        if(maxDate != null){
        	crit.add(t, TRAN_CREATED_DATE, maxDate, Criteria.LESS_THAN); 
        }

        if(minDate != null){
        	crit.add(t, TRAN_CREATED_DATE, minDate, Criteria.GREATER_THAN); 
        }
        
        // end date criteria
        Criteria.Criterion c1 = crit
            .getNewCriterion(a, ACT_END_DATE, date, Criteria.GREATER_THAN);
        c1.or(crit.getNewCriterion(a, ACT_END_DATE, null, Criteria.EQUAL));
        crit.add(c1);

        if (optionOrGroup instanceof ReportGroup) 
        {
            List options = ((ReportGroup)optionOrGroup)
                .getReportOptionAttributes();
            if (options != null && options.size() > 0) 
            {            
                Integer[] nks = new Integer[options.size()];
                for (int i=0; i<nks.length; i++) 
                {
                    nks[i] = ((ReportOptionAttribute)options.get(i))
                        .getOptionId();
                }
                
                crit.addIn(a+'.'+ACT_NEW_OPTION_ID, nks);
            }
            else 
            {
                List users = ((ReportGroup)optionOrGroup)
                    .getReportUserAttributes();
                if (users != null && users.size() > 0) 
                {            
                    Integer[] nks = new Integer[users.size()];
                    for (int i=0; i<nks.length; i++) 
                    {
                        nks[i] = ((ReportUserAttribute)users.get(i))
                            .getUserId();
                    }
                    
                    crit.addIn(a+'.'+ACT_NEW_USER_ID, nks);
                }
                else 
                {
                    // group is empty make sure there are no results
                    crit.add(a+'.'+ACT_NEW_OPTION_ID, -1);
                }
            }
        }
        else if (optionOrGroup instanceof ReportOptionAttribute)
        {
            crit.add(a, ACT_NEW_OPTION_ID, 
                     ((ReportOptionAttribute)optionOrGroup).getOptionId());
        }
        else if (optionOrGroup instanceof ReportUserAttribute)
        {
            ReportUserAttribute rua = (ReportUserAttribute)optionOrGroup;
            Integer attributeId = rua.getAttributeId();
            if (attributeId.intValue() == 0)
            {
                // committed by
                crit.add(t, TRAN_TYPE_ID, 
                         ActivitySetTypePeer.CREATE_ISSUE__PK);
                crit.add(t, TRAN_CREATED_BY, rua.getUserId());
            }
            else 
            {
                crit.add(a, ACT_ATTRIBUTE_ID, rua.getAttributeId());
                crit.add(a, ACT_NEW_USER_ID, rua.getUserId());
            }
        }
    }
0 0
(Domain) ScarabUpdateException 2 
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        // find the corresponding attribute
        Attribute attr;
        Criteria crit = new Criteria();
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        List attrList = AttributePeer.doSelect(crit);
        if (attrList.size() == 1) {
            attr = (Attribute) attrList.get(0);
        } else {
            throw new ScarabUpdateException(
                    "Found " + attrList.size() + " attributes for " + attribute + ".");
        }
        return attr;
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getOptionAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        Attribute attr = getAttribute(attribute);
        if (attr.isOptionAttribute()) {
            // do nothing
        } else {
            throw new ScarabUpdateException(
                    "Found non-optiontype attribute when an option type attribte was expected.");
        }
        return attr;
    }
0 5
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        // find the corresponding attribute
        Attribute attr;
        Criteria crit = new Criteria();
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        List attrList = AttributePeer.doSelect(crit);
        if (attrList.size() == 1) {
            attr = (Attribute) attrList.get(0);
        } else {
            throw new ScarabUpdateException(
                    "Found " + attrList.size() + " attributes for " + attribute + ".");
        }
        return attr;
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getOptionAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        Attribute attr = getAttribute(attribute);
        if (attr.isOptionAttribute()) {
            // do nothing
        } else {
            throw new ScarabUpdateException(
                    "Found non-optiontype attribute when an option type attribte was expected.");
        }
        return attr;
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public List getAttributeOptions(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.add(AttributeOptionPeer.DELETED, false);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                AttributeOptionPeer.ATTRIBUTE_ID);
        return AttributeOptionPeer.doSelect(crit);
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private List getModuleAttributes(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                RModuleAttributePeer.ATTRIBUTE_ID);
        List matOptions = RModuleAttributePeer.doSelect(crit);

        return matOptions;
    }
              
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private List getIssueTypes(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                RIssueTypeAttributePeer.ATTRIBUTE_ID);
        crit.addJoin(IssueTypePeer.ISSUE_TYPE_ID,
                RIssueTypeAttributePeer.ISSUE_TYPE_ID);
        List itOptions = IssueTypePeer.doSelect(crit);

        return itOptions;
    }
(Lib) TorqueRuntimeException 2 
              
// in java/org/tigris/scarab/om/MITList.java
public void remove()
        {
            List rawList = null;
            try
            {
                rawList = getMITListItems();
            }
            catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }

            if (rawList.contains(currentObject))
            {
                rawList.remove(currentObject);
                i.remove();
                expandedList = null;
            }
            else
            {
                throw new UnsupportedOperationException(
                    "Removing items "
                        + "from a list containing wildcards is not supported."); //EXCEPTION
            }
        }
              
// in java/org/tigris/scarab/om/MITList.java
public List getExpandedMITListItems()
    {
        if (expandedList == null)
        {
            List items = new ArrayList();
            try
            {
                for (Iterator rawItems = getMITListItems().iterator();
                    rawItems.hasNext();
                    )
                {
                    MITListItem item = (MITListItem) rawItems.next();
                    calculateIsAllMITs(item);
                    if (!item.isSingleModule())
                    {
                        Module[] modules =
                            getScarabUser().getModules(
                                ScarabSecurity.ISSUE__SEARCH);
                        for (int i = 0; i < modules.length; i++)
                        {
                            Module module = modules[i];
                            if (item.isSingleIssueType())
                            {
                                IssueType type = item.getIssueType();
                                if (module.getRModuleIssueType(type) != null)
                                {
                                    MITListItem newItem =
                                        MITListItemManager.getInstance();
                                    newItem.setModule(module);
                                    newItem.setIssueType(type);
                                    newItem.setListId(getListId());
                                    items.add(newItem);
                                }
                            }
                            else
                            {
                                addIssueTypes(module, items);
                            }
                        }
                    }
                    else if (!item.isSingleIssueType())
                    {
                        addIssueTypes(getModule(item), items);
                    }
                    else
                    {
                        items.add(item);
                    }
                }
            }
            catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            expandedList = items;
        }

        return expandedList;
    }
2
              
// in java/org/tigris/scarab/om/MITList.java
catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
              
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
0
(Lib) UnknownEntityException 2 
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public void saveGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            if (!((Persistent)group).isNew()) 
            {
                group.save();
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void removeGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            lockExclusive();
            if (!((Persistent)group).isNew()) 
            {
                ((Module)group).setDeleted(true);
                group.save();
                getAllGroups().remove(group);
            }
        }
        catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
0 4
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public void saveGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            if (!((Persistent)group).isNew()) 
            {
                group.save();
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void removeGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            lockExclusive();
            if (!((Persistent)group).isNew()) 
            {
                ((Module)group).setDeleted(true);
                group.save();
                getAllGroups().remove(group);
            }
        }
        catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void renameGroup(Group group, String name)
        throws DataBackendException, UnknownEntityException
    {
        throw new DataBackendException("rename is not supported"); //EXCEPTION

        /* this stuff is cut-n-paste
        boolean groupExists = false;
        try
        {
            lockExclusive();
            groupExists = checkExists(group);
            if(groupExists)
            {
                ((SecurityObject)group).setName(name);
                Criteria criteria = GroupPeer.buildCriteria(group);
                GroupPeer.doUpdate(criteria);
                return;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("renameGroup(Group,String)" ,e);
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'");
        */
    }
              
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
public User getAuthenticatedUser(String username, String password)
        throws DataBackendException, UnknownEntityException, 
            PasswordMismatchException {
        LDAPUserInfoCallback info = authenticate(username, password);

        /* First try to auth from ldap */
        if (info != null) {
            /* Check if user exists */
            if (!super.userManager.accountExists(username)) {
                try {
                    super.userManager.createAccount(createUser(username,
                            password, info), password);
                } catch (EntityExistsException e) {
                }

                
            } else {
                User curruser = userManager.retrieve(username);
                copyProps(curruser, info);

                String encrypted = TurbineSecurity.encryptPassword(password);

                if (!encrypted.equals(curruser.getPassword())) {
                    curruser.setPassword(encrypted);
                }

                userManager.store(curruser);
            }

            return userManager.retrieve(username);
        }

        return userManager.retrieve(username, password);
    }
(Lib) BuildException 1 
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
public void execute() 
        throws BuildException
    {
        try
        {
            importIssues.execute();
        }
        catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
    }
1
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
1
              
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
public void execute() 
        throws BuildException
    {
        try
        {
            importIssues.execute();
        }
        catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
    }
(Lib) ClassCastException 1 
              
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public int compareTo(Object obj)
    {
        //TODO [HD] what about using instanceof, or
        //          probably better delete the whole
        //          if-block (see note n ScarabModule.compereTo()
        if (this.getClass() != obj.getClass())
        {
            throw new ClassCastException(); //EXCEPTION 
        }
        String name1 = ((Group)obj).getName();
        String name2 = this.getName();

        return name2.compareTo(name1);
    }
0 0
(Lib) EntityExistsException 1 
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized Group addGroup(Group group) 
        throws DataBackendException, EntityExistsException
    {
        try
        {
            lockExclusive();
            if (((Persistent)group).isNew()) 
            {
                group.save();
                // add the group to system-wide cache
                getAllGroups().add(group);
                return group;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        // the only way we could get here without return/throw tirggered
        // is that the groupExists was true.
        throw new EntityExistsException("Group '" + group + 
            "' already exists"); //EXCEPTION
    }
0 2
              
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void createNewUser()
        throws TorqueException, DataBackendException, EntityExistsException
    {
        // get a unique id for validating the user
        final String uniqueId = RandomStringUtils
                .randomAlphanumeric(UNIQUE_ID_MAX_LEN);
        // add it to the perm table
        setConfirmed(uniqueId);
        TurbineSecurity.addUser (this, getPassword());
        setPasswordExpire();
        
        // add any roles the anonymous user has, if she is enabled.
        if(ScarabUserManager.anonymousAccessAllowed())
        {
            final ScarabUserImpl anonymous = (ScarabUserImpl) ScarabUserManager.getAnonymousUser();
            final List/*<ScarabModule>*/ modules = anonymous.getNonGlobalModules();
            for(Iterator it0 = modules.iterator(); it0.hasNext(); )
            {
                final ScarabModule module = (ScarabModule)it0.next();
                final List/*<Roles>*/ roles = anonymous.getRoles(module);
                for(Iterator it1 = roles.iterator(); it1.hasNext(); )
                {
                    try 
                    {
                        final Role role = (Role) it1.next();
                        TurbineSecurity.grant(this, (Group) module, role);

                        // TODO: Needs to be refactored into the Users system?
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.GET_ACL);
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable) role, module);
                        
                    }catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
                }
            }
        }
    }
              
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized Group addGroup(Group group) 
        throws DataBackendException, EntityExistsException
    {
        try
        {
            lockExclusive();
            if (((Persistent)group).isNew()) 
            {
                group.save();
                // add the group to system-wide cache
                getAllGroups().add(group);
                return group;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        // the only way we could get here without return/throw tirggered
        // is that the groupExists was true.
        throw new EntityExistsException("Group '" + group + 
            "' already exists"); //EXCEPTION
    }
(Lib) Error 1 
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private void initVelocity()
        throws InitializationException
    {
        // Now we have to perform a couple of path translations
        // for our log file and template paths.
        String path = getRealPath(
            getConfiguration().getString(VelocityEngine.RUNTIME_LOG, null));

        if (path != null && path.length() > 0)
        {
            getConfiguration().setProperty(VelocityEngine.RUNTIME_LOG, path);
        }
        else
        {
            String msg = EmailService.SERVICE_NAME + " runtime log file " +
                "is misconfigured: '" + path + "' is not a valid log file";

            throw new Error(msg); //EXCEPTION
        }

        // Get all the template paths where the velocity
        // runtime should search for templates and
        // collect them into a separate vector
        // to avoid concurrent modification exceptions.
        String key;
        List keys = new ArrayList();
        for (Iterator i = getConfiguration().getKeys(); i.hasNext();)
        {
            key = (String) i.next();
            if (key.endsWith(RESOURCE_LOADER_PATH))
            {
                keys.add(key);
            }
        }

        // Loop through all template paths, clear the corresponding
        // velocity properties and translate them all to the webapp space.
        int ind;
        List paths;
        String entry;
        for (Iterator i = keys.iterator(); i.hasNext();)
        {
            key = (String) i.next();
            paths = getConfiguration().getList(key,null);
            if (paths != null)
            {
                velocityEngine.clearProperty(key);
                getConfiguration().clearProperty(key);

                for (Iterator j = paths.iterator(); j.hasNext();)
                {
                    path = (String) j.next();
                    if (path.startsWith(JAR_PREFIX + "file"))
                    {
                        // A local jar resource URL path is a bit more
                        // complicated, but we can translate it as well.
                        ind = path.indexOf("!/");
                        if (ind >= 0)
                        {
                            entry = path.substring(ind);
                            path = path.substring(9,ind);
                        }
                        else
                        {
                            entry = "!/";
                            path = path.substring(9);
                        }
                        path = JAR_PREFIX + "file:" + getRealPath(path) +
                            entry;
                    }
                    else if (path.startsWith(ABSOLUTE_PREFIX))
                    {
                        path = path.substring (ABSOLUTE_PREFIX.length(),
                                               path.length());
                    }
                    else if (!path.startsWith(JAR_PREFIX))
                    {
                        // But we don't translate remote jar URLs.
                        path = getRealPath(path);
                    }
                    // Put the translated paths back to the configuration.
                    getConfiguration().addProperty(key,path);
                }
            }
        }

        try
        {
            velocityEngine.setExtendedProperties(ConfigurationConverter
                    .getExtendedProperties(getConfiguration()));

            velocityEngine.init();
        }
        catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
    }
0 0
(Domain) IncompatibleMITListException 1 
              
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setMITList(MITList mitList)
        throws Exception
    {
        if (mitList == null) 
        {
            reportDefn.setModuleIssueTypes(null);
            setModule(null);
            setIssueType(null);
        }
        else 
        {
            boolean isOk = true;
            // need to check that the changes are compatible with the currently
            // selected criteria
            for (Iterator roai = reportDefn
                .retrieveAllReportOptionAttributes().iterator(); 
                 roai.hasNext() && isOk;) 
            {
                isOk = mitList.isCommon( AttributeOptionManager.getInstance( 
                    ((ReportOptionAttribute)roai.next())
                    .getOptionId()));
            }
            for (Iterator ruai = reportDefn
                .retrieveAllReportUserAttributes().iterator(); 
                 ruai.hasNext() && isOk;) 
            {
                isOk = mitList.isCommon( AttributeManager.getInstance( 
                    ((ReportUserAttribute)ruai.next())
                    .getAttributeId()));
            }
            
            if (!isOk) 
            {
                throw new IncompatibleMITListException(L10NKeySet.ExceptionIncompatibleMITListChanges); //EXCEPTION
            }
            
            reportDefn.setModuleIssueTypes(null);
            setModule(null);
            setIssueType(null);

            for (Iterator i = mitList.getExpandedMITListItems().iterator(); i.hasNext();) 
            {
                MITListItem item = (MITListItem)i.next();
                ModuleIssueType mit = new ModuleIssueType();
                mit.setModuleId(item.getModuleId());
                mit.setIssueTypeId(item.getIssueTypeId());
                reportDefn.addModuleIssueType(mit);
            }
            if (mitList.isSingleModule()) 
            {
                torqueReport.setModule(mitList.getModule());
            }
            if (mitList.isSingleIssueType()) 
            {
                torqueReport.setIssueType(mitList.getIssueType());
            }
        }
    }
0 0
(Lib) ServiceException 1 
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private final void renderingError(String filename, Throwable e)
        throws ServiceException
    {
        String err = "Error rendering Velocity template: " + filename;
        getCategory().error(err + ": " + e.getMessage());
        // if the Exception is a MethodInvocationException, the underlying
        // Exception is likely to be more informative, so rewrap that one.
        if (e instanceof MethodInvocationException)
        {
            e = ((MethodInvocationException)e).getWrappedThrowable();
        }

        throw new ServiceException(err, e); //EXCEPTION
    }
0 15
              
// in java/org/tigris/scarab/actions/ModifyIssue.java
private REASON_SAVE_MODE saveReason(RunData data, final boolean isReasonRequired,
            final Group reasonGroup) throws ServiceException 
    {
        REASON_SAVE_MODE saveMode = REASON_SAVE_MODE.NONE;
        if(reasonGroup != null)
        {
        	// The reasonField is visible, so we can process it
            final Field reasonField = reasonGroup.get("Data");
            
            if(isReasonRequired)
            {
                reasonField.setRequired(true);
            }
            
            // make sure to trim the whitespace
            String reasonFieldString = reasonField.toString();
            if (reasonFieldString != null)
            {
                reasonFieldString = reasonFieldString.trim();
            }
            String saveAsFieldString = data.getParameters().get("saveReasonAs");
            if (saveAsFieldString != null)
            {
                saveAsFieldString = saveAsFieldString.trim();
            }
            final boolean saveAsComment = "Comment".equalsIgnoreCase(saveAsFieldString);
            saveMode = (saveAsComment)? REASON_SAVE_MODE.COMMENT:REASON_SAVE_MODE.HISTORY;
            
            if (!reasonField.isValid() || reasonFieldString.length() == 0)
            {
                if (isReasonRequired)
                {
                    reasonField.setMessage(
                        "ExplanatoryReasonRequiredToModifyAttributes");
                }
            }
        }
        return saveMode;
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static void handleRequest(Context context, String filename, 
                                     Writer writer)
        throws ServiceException
    {
        getService().handleRequest(context, filename, writer, null);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static void handleRequest(Context context, String filename,
                                     Writer writer, String encoding)
        throws ServiceException
    {
        getService().handleRequest(context, filename, writer, encoding);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public String handleRequest(TemplateContext context, String template)
        throws ServiceException
    {
        return handleRequest(new ContextAdapter(context), template);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public String handleRequest(Context context, String filename)
        throws ServiceException
    {
        return handleRequest(context, filename, (String)null, null);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public String handleRequest(Context context, String filename,
                                String charset, String encoding)
        throws ServiceException
    {
        String results = null;
        if (charset == null)
        {
            StringWriter writer = null;
            try
            {
                writer = new StringWriter();
                handleRequest(context, filename, writer, encoding);
                results = writer.toString();
            }
            catch (Exception e)
            {
                renderingError(filename, e);
            }
            finally
            {
                try
                {
                    if (writer != null)
                    {
                        writer.close();
                    }
                }
                catch (IOException ignored)
                {
                }
            }
        }
        else 
        {
        ByteArrayOutputStream bytes = null;
        try
        {
            bytes = new ByteArrayOutputStream();
            charset = decodeRequest(context, filename, bytes, charset,
                                    encoding);
            results = bytes.toString(charset);
        }
        catch (Exception e)
        {
            renderingError(filename, e);
        }
        finally
        {
            try
            {
                if (bytes != null)
                {
                    bytes.close();
                }
            }
            catch (IOException ignored)
            {
            }
        }
        }
        
        return results;
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(TemplateContext context, String template,
                              OutputStream outputStream)
        throws ServiceException
    {
        handleRequest(new ContextAdapter(context), template, outputStream);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(Context context, String filename,
                              OutputStream output)
        throws ServiceException
    {
        handleRequest(context, filename, output, null, null);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(Context context, String filename,
                              OutputStream output, String charset,
                              String encoding)
        throws ServiceException
    {
        decodeRequest(context, filename, output, charset, encoding);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(TemplateContext context,
                                       String template, Writer writer)
        throws ServiceException
    {
        handleRequest(new ContextAdapter(context), template, writer);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(Context context, String filename,
                              Writer writer)
        throws ServiceException
    {
        handleRequest(context, filename, writer, null);
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(Context context, String filename,
                              Writer writer, String encoding)
        throws ServiceException
    {
        try
        {
            // If the context is not already an instance of
            // InternalEventContext, wrap it in a VeclocityContext so that
            // event cartridges will work. Unfortunately there is no interface
            // that extends both Context and InternalEventContext, so this
            // is not as clear as it could be.

            Context eventContext;

            if ( context instanceof InternalEventContext )
            {
                eventContext = context;
            }
            else
            {
                eventContext = new VelocityContext( context );
            }

            if (encoding == null)
            {
                encoding = DEFAULT_CHAR_SET;
            }

            // Request scoped encoding first supported by Velocity 1.1.
            velocityEngine.mergeTemplate(filename, encoding,
                                         eventContext, writer);
        }
        catch (Exception e)
        {
            renderingError(filename, e);
        }
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private String decodeRequest(Context context, String filename,
                                 OutputStream output, String charset,
                                 String encoding)
        throws ServiceException
    {
        if (charset == null)
        {
            charset = DEFAULT_CHAR_SET;
        }

        OutputStreamWriter writer = null;
        try
        {
            try
            {
                writer = new OutputStreamWriter(output, charset);
            }
            catch (Exception e)
            {
                renderingError(filename, e);
            }
            handleRequest(context, filename, writer, encoding);
        }
        finally
        {
            try
            {
                if (writer != null)
                {
                    writer.flush();
                }
            }
            catch (Exception ignored)
            {
            }
        }
        return charset;
    }
              
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private final void renderingError(String filename, Throwable e)
        throws ServiceException
    {
        String err = "Error rendering Velocity template: " + filename;
        getCategory().error(err + ": " + e.getMessage());
        // if the Exception is a MethodInvocationException, the underlying
        // Exception is likely to be more informative, so rewrap that one.
        if (e instanceof MethodInvocationException)
        {
            e = ((MethodInvocationException)e).getWrappedThrowable();
        }

        throw new ServiceException(err, e); //EXCEPTION
    }
              
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
protected String handleRequest(final String template,
                                   final boolean bEscapeHTML)
        throws ServiceException
    {
        StringWriter sw = new StringWriter();
        
        ScarabLocalizationTool l10n = (ScarabLocalizationTool)
                context.get(ScarabConstants.LOCALIZATION_TOOL);
        
        if (l10n != null)
        {
            final boolean pushFilterEnable = l10n.isFilterEnabled();

            if (bEscapeHTML == true)
            {
                l10n.setFilterEnabled(false);
            }
        
            try
            {
                VelocityEmail.handleRequest(new ContextAdapter(context), template, sw);
            }
            finally
            {
                l10n.setFilterEnabled(pushFilterEnable);
            }
        }
        else
        {
            VelocityEmail.handleRequest(new ContextAdapter(context), template, sw);
        }

        return sw.toString();
    }
(Lib) ServletException 1 
              
// in java/org/tigris/scarab/tools/install/web/SaveSettingsServlet.java
public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		String redirect = null;
		Properties properties = (Properties) request.getSession().getAttribute("properties");
		
		Map parameterMap = request.getParameterMap( );
		if (parameterMap == null)
	        throw new ServletException("getParameterMap returned null in: " + getClass( ).getName( ));

		Iterator iterator = parameterMap.entrySet( ).iterator( );
		while(iterator.hasNext( )){
			Map.Entry me = (Map.Entry)iterator.next( );
			String key = (String) me.getKey();
			String[] arr = (String[]) me.getValue( );
			String value = arr[0];
			System.out.println("Key: [" + key + "] Value: [" + value + "]");

			if ("redirect".equals(me.getKey())) {
				redirect = value;
			}

			if (key.indexOf('.') != -1) {
				properties.setProperty(key, value);
			}
		}

		if (redirect == null) {
			System.out.println("ERROR: no redirect specified, redirect to BasicSettings.jsp");
		}
		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL(redirect));
	}
0 7
              
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		System.out.println("User dir:" + System.getProperty("user.dir"));
		System.out.println("Now reading project.properties");
		Properties properties = new Properties();
	    try {
	        properties.load(new FileInputStream("../../project.properties"));
	    } catch (IOException e) {
	    	e.printStackTrace();
	    }

	    try {
	        properties.load(new FileInputStream("../../build.properties"));
	    } catch (IOException e) {
	    	System.out.println("There is probably no build.properties file.");
	    }
	    
	    // Init HTTP scheme information
	    // Since the installer runs in the same container as the Scarab to
	    // be built, getting these informations from the request probably
	    // makes more sense than the default values.
	    properties.setProperty("scarab.http.scheme", request.getScheme());
	    properties.setProperty("scarab.http.domain", request.getServerName());
	    properties.setProperty("scarab.http.port", new Integer(request.getServerPort()).toString());
	    
	    // Init additional properties for the database generation.
	    properties.setProperty("skip.seed.data", "false");
	    properties.setProperty("skip.jira.templates.data", "false");
	    
	    request.getSession().setAttribute("properties", properties);
	    
		response.sendRedirect(response.encodeRedirectURL("BasicSettings.jsp"));
	}
              
// in java/org/tigris/scarab/tools/install/web/SaveSettingsServlet.java
public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		String redirect = null;
		Properties properties = (Properties) request.getSession().getAttribute("properties");
		
		Map parameterMap = request.getParameterMap( );
		if (parameterMap == null)
	        throw new ServletException("getParameterMap returned null in: " + getClass( ).getName( ));

		Iterator iterator = parameterMap.entrySet( ).iterator( );
		while(iterator.hasNext( )){
			Map.Entry me = (Map.Entry)iterator.next( );
			String key = (String) me.getKey();
			String[] arr = (String[]) me.getValue( );
			String value = arr[0];
			System.out.println("Key: [" + key + "] Value: [" + value + "]");

			if ("redirect".equals(me.getKey())) {
				redirect = value;
			}

			if (key.indexOf('.') != -1) {
				properties.setProperty(key, value);
			}
		}

		if (redirect == null) {
			System.out.println("ERROR: no redirect specified, redirect to BasicSettings.jsp");
		}
		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL(redirect));
	}
              
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		PrintWriter out = response.getWriter();
		
		try {
			ResourceBundle rb = ResourceBundle.getBundle("InstallBundle");

			File currentDirectory = new File(System.getProperty("user.dir"));
			String buildDirectoryName = currentDirectory.getParentFile().getParentFile().getAbsolutePath() + File.separatorChar + "build";
			String commandLine1 = null;
			
			// Write a couple of batch (command) file
			// I could not find another way to launch ant in another directory
			if ("Windows".equals(System.getProperty("os.name").substring(0, 7))) {
		        BufferedWriter batch1 = new BufferedWriter(new FileWriter("build-scarab.cmd"));
		        batch1.write("cd " + buildDirectoryName + "\r\n");
		        batch1.write("ant\r\n");
		        batch1.close();
		        
		        commandLine1 = "cmd /c build-scarab.cmd";
			} else {
		        BufferedWriter batch1 = new BufferedWriter(new FileWriter("build-scarab"));
		        batch1.write("#! /bin/sh\n");
		        batch1.write("cd " + buildDirectoryName + "\n");
		        batch1.write("ant\n");
		        batch1.close();
		        
		        commandLine1 = "sh ./build-scarab";
			}

			// Launch first batch to build Scarab
			out.println("<div class=\"infomessage\">");
			out.println("<strong>Phase 1</strong> : " + rb.getString("building.scarab.application"));
			out.println("</div>");
			
			Process child = Runtime.getRuntime().exec(commandLine1);
			
			out.println("<pre>");
			InputStream in = child.getInputStream();
			int c;
			while ((c = in.read()) != -1) {
				out.print((char) c);
			}
			out.println("</pre>");
			in.close();
			
			if (child.exitValue() == 0) {
				out.println("<p class=\"infomark\">" + rb.getString("success") + "</p>");
			} else {
				out.println("<p class=\"errormark\">" + rb.getString("failure") + "</p>");
			}
		} catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		} catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
			
		}
		
	}
              
// in java/org/tigris/scarab/tools/install/web/Build1Servlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		Properties properties = (Properties) request.getSession().getAttribute("properties");
		System.out.println("Now writing the build.properties file.");
		properties.store(new FileOutputStream("../../build.properties"), "Generated by ScarabWebInstaller");
		System.out.println("Done.");
		
		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL("Build1.jsp"));

	}
              
// in java/org/tigris/scarab/tools/install/web/Build2Servlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL("Build2.jsp"));

	}
              
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		PrintWriter out = response.getWriter();
		

		try {
			ResourceBundle rb = ResourceBundle.getBundle("InstallBundle");

			File currentDirectory = new File(System.getProperty("user.dir"));
			String buildDirectoryName = currentDirectory.getParentFile().getParentFile().getAbsolutePath() + File.separatorChar + "build";
			String commandLine2 = null;
			
			// Write a couple of batch (command) file
			// I could not find another way to launch ant in another directory
			if ("Windows".equals(System.getProperty("os.name").substring(0, 7))) {
		        BufferedWriter batch2 = new BufferedWriter(new FileWriter("build-scarab-db.cmd"));
		        batch2.write("cd " + buildDirectoryName + "\r\n");
		        batch2.write("ant create-db\r\n");
		        batch2.close();
		        
		        commandLine2 = "cmd /c build-scarab-db.cmd";
			} else {
		        BufferedWriter batch2 = new BufferedWriter(new FileWriter("build-scarab-db"));
		        batch2.write("#! /bin/sh\n");
		        batch2.write("cd " + buildDirectoryName + "\n");
		        batch2.write("ant\n");
		        batch2.close();
		        
		        commandLine2 = "sh ./build-scarab-db";
			}

			// Launch second batch to build the Scarab database
			out.println("<div class=\"infomessage\">");
			out.println("<strong>Phase 2</strong> : " + rb.getString("building.scarab.database"));
			out.println("</div>");
			
			Process child = Runtime.getRuntime().exec(commandLine2);
			
			out.println("<pre>");
			InputStream in = child.getInputStream();
			int c;
			while ((c = in.read()) != -1) {
				out.print((char) c);
			}
			out.println("</pre>");
			in.close();
			
			if (child.exitValue() == 0) {
				out.println("<p class=\"infomark\">" + rb.getString("success") + "</p>");
			} else {
				out.println("<p class=\"errormark\">" + rb.getString("failure") + "</p>");
			}
		} catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		} catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
		}
		
	}
              
// in java/org/tigris/scarab/util/AntServlet.java
public final void init(ServletConfig config)
        throws ServletException
    {
        super.init(config);

        String command = config.getInitParameter("buildCommand");
        if (command != null)
        {
            buildCommand = command;
            System.out.println ("AntServlet Command: " + 
                buildCommand);
        }
        String file = config.getInitParameter("buildFile");
        if (file != null)
        {
            buildFile = new File(file);
            System.out.println ("AntServlet File: " + 
                buildFile.getAbsolutePath());
        }
    }
(Lib) UnsupportedCallbackException 1 
              
// in java/org/tigris/scarab/services/security/ldap/DummyCallbackHandler.java
public void handle(Callback[] callbacks) throws IOException,
			UnsupportedCallbackException {
		for (int i = 0; i < callbacks.length; i++) {
			if (callbacks[i] instanceof NameCallback) {
				((NameCallback) callbacks[i]).setName(username);
			} else if (callbacks[i] instanceof PasswordCallback) {
				((PasswordCallback) callbacks[i]).setPassword(password);
            } else if (callbacks[i] instanceof LDAPUserInfoCallback) {
                ldapUserInfo = (LDAPUserInfoCallback) callbacks[i];
			} else {
				throw new UnsupportedCallbackException(callbacks[i],
						"Callback class not supported");
			}
		}
	}
0 1
              
// in java/org/tigris/scarab/services/security/ldap/DummyCallbackHandler.java
public void handle(Callback[] callbacks) throws IOException,
			UnsupportedCallbackException {
		for (int i = 0; i < callbacks.length; i++) {
			if (callbacks[i] instanceof NameCallback) {
				((NameCallback) callbacks[i]).setName(username);
			} else if (callbacks[i] instanceof PasswordCallback) {
				((PasswordCallback) callbacks[i]).setPassword(password);
            } else if (callbacks[i] instanceof LDAPUserInfoCallback) {
                ldapUserInfo = (LDAPUserInfoCallback) callbacks[i];
			} else {
				throw new UnsupportedCallbackException(callbacks[i],
						"Callback class not supported");
			}
		}
	}
Explicit thrown (throw new...): 305/325
Explicit thrown ratio: 93.8%
Builder thrown ratio: 0%
Variable thrown ratio: 6.2%
Checked Runtime Total
Domain 2 8 10
Lib 12 87 99
Total 14 95

Caught Exceptions Summary

A (Domain) exception is defined in the application. A (Lib) exception is defined in the JDK or in a library. An exception can be caught, and it happens that the catch block contains a throw (e.g. for wrapping a low-level exception). Hovering over a number triggers showing code snippets from the application code.

Type Exception Caught
(directly)		 Caught
with Thrown
(Lib) Exception 292 
            
// in java/org/tigris/scarab/pipeline/AnonymousLoginValve.java
catch(Exception e)
                    {
                        // login failed (user unknown, not confirmed, wrong password, ...) no action taken here
                        // Maybe even anonymous login should be forbidden now ?
                        // See below
                    }
            
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
catch (Exception e)
                {
                    LOG.debug("Could not set high buffer size so client may " +
                              "affect timing results.");
                }
            
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
catch (Exception ignore)
                {
                    // maybe this was a binary response?
                    // we still logged it, so ignore
                }
            
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
catch (Exception e)
            {
                LOG.warn(
                    "Could not set locale info for user ["
                        + user.getName()
                        + "]");
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Could not get list attributes", e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
		{
		e.printStackTrace(); throw e; //EXCEPTION
		}
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // Swallow me!
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
                {
                    issueType = new IssueType(defaultIssueTypeId);
                }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
        e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
            {
                Log.get().info("[ScarabRequestTool] Unable to retrieve Module: " +
                         key, e);
            }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // system would be messed up, if we are here.  Punt
            nextTemplate = "Index.vm";
            setAlertMessage(L10NKeySet.CannotDetermineIssueEntryTemplate);
            Log.get().error("CannotDetermineIssueEntryTemplate", e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
            {
                setAlertMessage(L10NKeySet.InvalidId);
            }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            setAlertMessage(L10NKeySet.InvalidIssueId);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            valid = false;
            dateField.setMessage("format error ["+e.getMessage()+"]");
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Problem getting user list", e);
            list = new ScarabPaginatedList();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            hasPermission = false;
            Log.get().error("Permission check failed on:" + permission, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            hasPermission = false;
            Log.get().error("Permission check failed on:" + permission, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().debug("Error: ", e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // Nothing to do. Ignore.
        }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
catch (Exception e)
        {
            // Logged at debug level, as a null user is interpreted
            // as an invalid user name
            Log.get().debug("User, "+username+" could not be found,", e);
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch(Exception e)
        {
            value = createBadResourceValue(key, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch(Exception e)
        {
            value = createBadResourceValue(key, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (Exception e)
        {
            value = createBadResourceValue(key, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (Exception e)
                {
                  // [HD] This should not happen, but it does happen;
                  // The problem raises when the system locale is not
                  // supported by Scarab. This was reported on Windows 
                  // systems. This needs to be further investigated.
                  // setting bundle to null here enforces usage of the
                  // default ResourceBundle (en-US)
                  bundle = null;
                }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
        {
            // return the text as is and log the error
            result = new ArrayList(1);
            result.add(text);
            Log.get().warn("Could not linkify text: " + text, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
            {
                Log.get().error(obj + " cannot convert to an integer.", e);
            }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
            {
                e.printStackTrace();
                moduleCodeLength = 4;
            }
            
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
			
		}
            
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
		}
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                key = "";
            }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            return super.toString();
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                throw new TorqueException(e);
            }
            
// in java/org/tigris/scarab/om/MITList.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
        {
            sb.append("Error retrieving list items. see logs.");
            Log.get().warn("", e);
        }
            
// in java/org/tigris/scarab/om/Query.java
catch (Exception e)
                {
                    exception = e;
                }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Activity.java
catch (Exception e)
            {
                getLog().error("Activity.getAttachment(): ", e);
            }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
            {
                getLog().error(e);
                dispVal = "!Error-Check Logs!";
            }
            
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
            {
                getLog().error(e);
                dispVal = "!Error-Check Logs!";
            }
            
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
            
// in java/org/tigris/scarab/om/ROptionOption.java
catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
            
// in java/org/tigris/scarab/om/Condition.java
catch (Exception e) {
            this.getLog().debug("evaluate: Failed to evaluate, will return false. ", e);
        }
            
// in java/org/tigris/scarab/om/Condition.java
catch (Exception e) {
            this.getLog().debug("evaluate: Failed to evaluate, will return empty String. ", e);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                getLog().error("Error getting HTTP_DOMAIN:", e);
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                getLog().error("Error getting DOMAIN_NAME:", e);
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            getLog().error("getCommentRenderingEngine(): " + e);
        }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(Exception e)
                    {
                        // [HD] Compare can not be performed, just ignore it (needs enhancement!!!)
                    }
            
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
            {
                Log.get().warn("Error accessing dedupe sequence for issue "
                               + "type '" + this + '\'', e);
                return sequence;
            }
            
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
        {
            Log.get().warn("Could not get RIA records for " + getName(), e);
        }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch (Exception e) 
            {
                Log.get().error("", e);
                // return null
            }
            
// in java/org/tigris/scarab/om/MITListItem.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
            {
                e.printStackTrace();
                getLog().error(e);
                return null;
            }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e) {
			e.printStackTrace();
			return false;
		}
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            getLog().error("Problem determining whether issue is template");
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            // ignored (return 0 by default)
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            getLog().error(e);
                            e.printStackTrace();
                        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            Log.get().error("Unable to retrieve user for "
                                            + "attribute", e);
                        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e)
            {
                getLog().error("An exception prevented retrieving any modules", e);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e){}
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception te)
        {
            getLog().error("getAssignIssuesList(): " + te);
        }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e) {
    			Log.get().error(e);
			}
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old issues.  "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old reports.  "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            Log.get().warn("Error determining user homepage", e);
        }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().warn("Could not determine query target.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old MIT lists.  "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old queries.  "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing entered issue types. "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                final L10NKey msg = new L10NKey("ErrorPossibleMemoryLeak");
                Log.get().warn(msg.getMessage(), e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            // I think it might be ok to return null from this method
            // but until that is investigated return the default in
            // event of error
            result = ScarabConstants.DEFAULT_LOCALE;
            Log.get().warn(
                "AbstractScarabUser.getLocale() could not "
                    + "retrieve locale for user id="
                    + getUserId()
                    + "; Error message: "
                    + e.getMessage());
        }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            
// in java/org/tigris/scarab/om/AttributePeer.java
catch (Exception e)
                {
                    //
                }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (Exception e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
catch (Exception e)
                {
                    //
                }
            
// in java/org/tigris/scarab/om/AttributeOption.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                    {
                        log.error("queueNotifications(): while processing activity queue: " + e.getMessage(),e);
                        logNotificationData(notification);
                        log.error("queueNotifications(): Abort this run");
                        break;
                    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
        {
            log.error("queueNotifications(): while setting up the activity queue: " + e.getMessage(),e);
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(Exception e)
        {
            log.error("queueNotifications(): while dumping notificationData: " + e.getMessage(),e);
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                    {
                        exception = e;
                        log.error("Failed to send email :" + e);
                    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                {
                    log.error("sendPendingNotifications(): Updating: " + e, e);
                }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
            {
                // [HD] Compare can not be performed, just ignore it (needs enhancement!!!)
            }
            
// in java/org/tigris/scarab/notification/NotificationManagerFactory.java
catch (Exception e)
            {
                log
                        .error("Could not instantiate notification manager '"
                                + classname + "'. Defaulting to '"
                                + ScarabNotificationManager.class.getName()
                                + "': " + e);
                instance = new ScarabNotificationManager();
            }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandlerClient.java
catch (Exception e)
        {
            System.err.println("Error invoking service: " + e);
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("addAttributeOption(String, String) -  : attr=" + attr 
                    + ", opt=" + opt + ", rslt=" + rslt, e);

            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", options=" + options + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandlerClient.java
catch (Exception e)
        {
            System.err.println("Error invoking service: " + e);
        }
            
// in java/org/tigris/scarab/screens/ReportExport.java
catch (Exception e)
        {
            printer.print(l10n.get("ErrorOccurredCheckingMessage"));
        }
            
// in java/org/tigris/scarab/screens/SaveTemplate.java
catch (Exception e)
        {
            title = l10n.get("SaveTemplate");
            Log.get().debug("no current issue type, cannot retrieve SaveTemplate title", e);
        }
            
// in java/org/tigris/scarab/screens/ViewIssue.java
catch(Exception e){
			//ignore, this case will be handled later: issue == null
		}
            
// in java/org/tigris/scarab/screens/Default.java
catch (Exception ignore)
        {
        }
            
// in java/org/tigris/scarab/screens/Default.java
catch (Exception e)
            {
                Log.get().info(
                    "Error getting page title for Screen: " + data.getTarget());
            }
            
// in java/org/tigris/scarab/screens/admin/ViewXMLExportIssues.java
catch (Exception e)
                {
                    data.setTarget("admin,XMLExportIssues.vm");
                    scarabR.setAlertMessage(l10n.getMessage(e));
                    return;
                }
            
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
catch (Exception e)
                {
                    resultCode = RESULT_ERROR_EXCEPTION;
                    // TODO: Improve localizability of this text.
                    resultString = l10n.get("ProcessingErrors") + ": "
                        + e.getMessage();
                }
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
            
// in java/org/tigris/scarab/screens/ModuleSwitchingLink.java
catch (Exception e)
        {
            Log.get().error("Could not determine homepage", e);
            homePage = "Index.vm";
        }
            
// in java/org/tigris/scarab/screens/MoveIssue.java
catch (Exception e)
        {
            title = "Error; Copy or Move?";
            Log.get().warn("Error determining title", e);
        }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
catch( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/Search.java
catch(Exception e)
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneral,e);
                    scarabR.setAlertMessage(msg);
                }
            
// in java/org/tigris/scarab/actions/Search.java
catch(Exception e)
        {
            // no module selected
            return;
        }
            
// in java/org/tigris/scarab/actions/TemplateList.java
catch (Exception e)
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.getMessage(e));
                }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
                {
                    // would probably be a hack of the form
                    scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                    Log.get().debug("", e);
                    return;
                }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.InvalidId);
            Log.get().warn("An invalid id was entered: "+listId);
        }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
            
// in java/org/tigris/scarab/actions/QueryList.java
catch (Exception e)
               {
                   ScarabLocalizationTool l10n = getLocalizationTool(context);
                   getScarabRequestTool(context).setAlertMessage(NO_PERMISSION_MESSAGE);
               }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception se)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        return;
                    }
            
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
catch(Exception e)
                        {
                            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.CouldNotSendNotification,e);
                            scarabR.setAlertMessage(l10nMessage);
                        }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (Exception e)
                    {
                        L10NMessage l10nMessage =new L10NMessage(EMAIL_ERROR,e);
                        scarabR.setAlertMessage(l10nMessage);
                    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
catch (Exception e)
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch(Exception e)
                            {
                                Localizable msg = new L10NMessage(L10NKeySet.ExceptionEmailFailure,e);
                                scarabR.setAlertMessage(msg);
                            }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
            
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
catch (Exception e)
                            {
                                scarabR.setAlertMessage(
                                    l10n.get("CannotDeleteIssueType"));
                                Log.get().warn(
                                    "Could not delete issue type", e);
                            }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
catch (Exception e)
               {
                   scarabR.setAlertMessage(l10n.get(NO_PERMISSION_MESSAGE));
               }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
catch (Exception e)
               {
                   scarabR.setAlertMessage(ScarabConstants.NO_PERMISSION_MESSAGE);
               }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
catch(Exception e)
                {
                    e.printStackTrace();
                }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                        {
                            scarabR.setAlertMessage(
                               l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                            {
                                log().error("Error adding attribute option:", e);
                                scarabR.setAlertMessage("Error adding attribute option:" + l10n.getMessage(e));
                            }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }
            
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
catch(Exception e)
                {
                    e.printStackTrace();
                }
            
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
catch (Exception e)
        {
            rule.setNew(true);
        }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
catch(Exception e)
                {
                    L10NMessage l10nMessage = new L10NMessage(EMAIL_ERROR,e);
                    scarabR.setAlertMessage(l10nMessage);
                }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception se)
        {
            scarabR.setAlertMessage(l10n.getMessage(se));
        }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
                return;
            }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch(Exception e)
            {
                String l10nMessage = l10n.getMessage(e);
                scarabR.setAlertMessage(l10nMessage);
                return;
            }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    // we do not want any exception thrown here to affect
                    // the user experience, it is just considered a 
                    // non-detectable file type.  But still the exception is
                    // not expected, so log it.
                    mimeAField.setMessage("intake_CouldNotDetermineMimeType");
                    Log.get().info(
                        "Could not determine mimetype of uploaded file.", e);
                }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
        {
            type.setMessage(l10n.get(L10NKeySet.SelectRelation));
            return false;
        }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch(Exception e)
        {
            // Ignore this
        }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
            {
                log().debug("Delete error: ", e);
                return false;
            }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    log().debug("Delete error: ", e);
                }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
            {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
            
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectModuleAndIssueType);
            return;
        }
            
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
            {
                L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
                scarabR.setAlertMessage(l10nMessage);
                Log.get().warn("Exception during issue copy/move", e);
                return;
            }
            
// in java/org/tigris/scarab/reports/ReportHeading.java
catch (Exception e)
                {
                    Log.get().warn("Error on attribute id", e);
                    result = false;
                }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            s = "ERROR! on " + super.toString();
            Log.get().error("", e);
        }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                Log.get().error("Error on Attribute Id=" + attId, e);
                return "Error on Attribute Id=" + attId;
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Attribute Id=" + attId;
                Log.get().error(result, e);
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Attribute Id=" + attId;
                Log.get().error(result, e);
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Option Id=" + optionId;
                Log.get().error(result, e);
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Option Id=" + optionId;
                Log.get().error(result, e);
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            result = "Error on Option Id=" + rua.getUserId();
            Log.get().error(result, e);
        }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
catch (Exception e)
        {
            result = false;
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (Exception e) {
            Log.get().error("filterConditionalTransitions: " + e);
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
            {
                renderingError(filename, e);
            }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            renderingError(filename, e);
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            renderingError(filename, e);
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
            {
                renderingError(filename, e);
            }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception ignored)
            {
            }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch(Exception ex)
        {
            log.error("Double error: Can not dump Email context. ("+ex.getMessage()+")");
            log.error("key["+keystring+"]");
            log.error("val["+val+"]");
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e )
        {
//            Log.error("cannot embed "+surl+": ", e);
        }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/TorqueService.java
catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/ScarabCache.java
catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
            
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
catch (Exception e) {
				logger.error("Exception caught: ", e);
			}
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/ComponentLocator.java
catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
            {
                LOG.warn("Could not assign nullAttribute", e);
            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotLocateUsername", userStr);
                    importErrors.add(error);
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "CouldNotFindGlobalAttribute", activityAttribute);
            importErrors.add(error);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption",
                                     activity.getOldOption());
                                importErrors.add(error);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
            
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not parse port number", e);
        }
            
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not get scheme parameter", e);
        }
            
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not get script name parameter", e);
        }
            
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            allowed = false;
            Log.get().info("Could not check permission due to: ", e);
        }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch (Exception e)
        {
        	
            valid = false;
       
        }
            
// in java/org/tigris/scarab/util/SnippetRenderer.java
catch (Exception e)
        {
            LOG.error("Error rendering " + template + ". ", e);
            result = "ERROR!";
        }
            
// in java/org/tigris/scarab/util/AntServlet.java
catch (Exception ignored)
            {
            }
            
// in java/org/tigris/scarab/util/IssueIdParser.java
catch (Exception e)
        {
            Log.get().error("An npe is going to occur because I could not " +
                            "compile regex: [:alpha:]*\\d+", e);
        }
            
// in java/org/tigris/scarab/util/IssueIdParser.java
catch(Exception e)
            {
                // Ignored on purpose
            }
            
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + className + '\'', e);
            }
            
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + linkClass.getName() + 
                               "'; will use default link tool.", e);
                result = new ErrorEmailLink(module);            
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch( Exception e)
        {
            analyzer = new PorterStemAnalyzer();
            Log.get().error("Could not create Lucene Analyzer (" + analyzerClassName + "), using default.", e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/SearchFactory.java
catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
            
// in java/org/tigris/scarab/util/TurbineInitialization.java
catch (Exception e)
        {
            System.err.println("Can't read the properties file (" + 
                configDir + configFile + "). ");
        }
            
// in java/org/tigris/scarab/util/Email.java
catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
            
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
        {
            log.error("Error rendering subject for " + template + ". ", e);
            result = "Scarab System Notification";
        }
            
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
        {
            log.debug("", e);
            // use the basic email
        }
            
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
            {
                log.error(
                        "Couldn't determine locale for user " + user
                                .getUserName(), e);
            }
            
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
            {
                Log.get().debug(e);
            }
            
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
        {
            Log.get().debug(e);
        }
            
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
        {
            Log.get().debug(e);
        }
77
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
		{
		e.printStackTrace(); throw e; //EXCEPTION
		}
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                throw new TorqueException(e);
            }
            
// in java/org/tigris/scarab/om/MITList.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
            
// in java/org/tigris/scarab/om/ROptionOption.java
catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/MITListItem.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
catch( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
            {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/TorqueService.java
catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/ScarabCache.java
catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/ComponentLocator.java
catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/SearchFactory.java
catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
(Lib) TorqueException 85 
            
// in java/org/tigris/scarab/pipeline/DetermineTargetValve.java
catch (TorqueException e)
                    {
                        target = null;
                    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
catch (TorqueException e)
        {
            return null;
        }
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
            
// in java/org/tigris/scarab/attribute/OptionAttribute.java
catch (TorqueException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException te)
        {
            // Nothing to do
        }
            
// in java/org/tigris/scarab/om/NotificationStatusPeer.java
catch (TorqueException e) 
        {
			log.error("getPendingNotifications(): " + e);
		}
            
// in java/org/tigris/scarab/om/NotificationStatusPeer.java
catch (TorqueException e) 
        {
            log.error("getPendingNotifications(): " + e);
        }
            
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
catch (TorqueException e)
        {
            Log.get().error("setInternalAttribute(): " + e);
        }
            
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
catch (TorqueException e)
        {
            getLog().error("getName(): " + e);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
        {
            getLog().error("isIssueReasonRequired(): " + te);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
                getLog().error("isIssueReasonVisible(): " + te);
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
        {
            getLog().error("isIssueReasonRequiredInherited(): " + te);
        }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch (TorqueException te)
        {
            getLog().error("setActivity(): Cannot find activity's issue!: " + te);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
            {
                e.printStackTrace();
            }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException te)
        {
            // Nothing to do
        }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch (TorqueException e)
            {
                Log.get().error("", e);
            }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
            
// in java/org/tigris/scarab/om/AttributeGroupManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid AttributeGroup id ", e);
            }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }
            
// in java/org/tigris/scarab/om/TransitionManager.java
catch (TorqueException te)
            {
                te.printStackTrace();
            }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException te)
        {
            // Nothing to do
        }
            
// in java/org/tigris/scarab/om/TransitionPeer.java
catch (TorqueException e) {
			log.error("getTransitions(): AttributeOption: " + fromOption.getOptionId() + ": " + e);
		}
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
catch (TorqueException e) {
                log.error("getPendingNotifications(): " + e);
            }
            
// in java/org/tigris/scarab/om/ActivitySet.java
catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (TorqueException e)
                    {
                        Log.get().error("Unable to sort on module names", e);
                    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
            {
                getLog().error("Error getting the issue type name: ", e);
            }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
            {
                getLog().error("Error getting the issue type description: ", e);
            }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException te)
        {
            // Nothing to do
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/UserPreferenceManager.java
catch (TorqueException te)
        {
            // Empty result...Failed to select one and only one row.
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
            {
                log.error("sendPendingNotifications(): No access to Issue [" + te + "]");
                // Can not proceed with this issue !
                continue;
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
                {
                    log.error("sendPendingNotifications(): No access to current Scarab User" + te);
                    // We can continue processing here. We just don't know how to process Emails
                    // for the current user.
                }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
        {
            Log.get().warn("Can not access Database while processing wakeupOnHoldTimeouts");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
        {
            Log.get().warn("Can not access Database while processing wakeupOnHoldTimeouts");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
        {
            Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
            Log.get().warn("db layer reported: ["+e.getMessage()+"]");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
            {
                Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                Log.get().warn("db layer reported: ["+e.getMessage()+"]");
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
                {
                    Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                    Log.get().warn("db layer reported: ["+e.getMessage()+"]");
                }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e) 
                {
                    uniqueComments.add(notificationStatus);
                }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
                    {
                        exception = te;
                    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
            {
                log.error("sendPendingNotifications(): " + te);
                continue;
            }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TorqueException e) {
                    if (log.isEnabledFor(org.apache.log4j.Priority.WARN)) {
                        log
                                .warn(
                                        "mapAttributeOptionToAllModuleIssueTypes(String, String) - IssueTypeMApping alreadyt exists for this combination : attribute=" + attribute + ", option=" + option + ", it=" + it, null); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                    }
                }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TorqueException e) {
                    log.error("Torque exception when sorting IssueTypeOptions.",e);
                }
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
            
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
catch (TorqueException e)
        {
            log().error("deleteRoleRequests: " + e); 
        }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (TorqueException te)
            {
                this.log().error("doSavetransitiondata(): " + te);
            }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (TorqueException te)
        {
            this.log().error("doDeleteTransition(): " + te);
        }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (TorqueException te) 
                        {
                            String msg = te.getMessage();
                            scarabR.setAlertMessage(msg);
                        }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (TorqueException e)
                {
                    alreadySubmited = true;
                    scarabR.setAlertMessage(L10NKeySet.ResubmitError);
                }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
        {
            Log.get(this.getClass().getName())
                    .error("canMakeTransition: " + te);
        }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
            
// in java/org/tigris/scarab/services/TorqueService.java
catch (TorqueException te)
        {
            Log.get("org.apache.fulcrum").error("TorqueService.shutdown(): " + te);
        }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (TorqueException e) {
            log.error(e);

            return null;
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException ex) 
                {
                    ex.printStackTrace();
                    importErrors.add(ex);
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/EmailLink.java
catch (TorqueException te) {
                }
25
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ActivitySet.java
catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Domain) ScarabException 14 
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (ScarabException e)
        {
            setAlertMessage(e.getL10nMessage());
        }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (ScarabException e) {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/actions/TemplateList.java
catch (ScarabException e)
                {
                    success = false;
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabException e)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(e));
                        Log.get().warn(
                            "This is an application error, if it is not permission related.", e);
                    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    scarabR.setAlertMessage(l10n.getMessage(se));
                }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
            {
                childId.setMessage(se.getL10nMessage().getMessage(l10n));
                return false;
            }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    // it will error out if they attempt to delete
                    // a dep via a child dep.
                    String l10nKey = se.getMessage();
                    scarabR.setAlertMessage(l10n.get(l10nKey));
                }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
3
            
// in java/org/tigris/scarab/om/Issue.java
catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (ScarabException e) {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
(Lib) IOException 13 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (IOException e)
                {
                    log.error("authenticateNtlm: " + e);
                }
            
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
catch (IOException e) {
	    	e.printStackTrace();
	    }
            
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
catch (IOException e) {
	    	System.out.println("There is probably no build.properties file.");
	    }
            
// in java/org/tigris/scarab/om/IssueType.java
catch(IOException ioe)
            {
                Log.get().warn("Exception while loading the file: IssueTypeConfig.properties", ioe);
            }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            
// in java/org/tigris/scarab/screens/ViewAttachment.java
catch (java.io.IOException ioe)
                    {
                        Log.get().debug("File download was aborted: " + 
                                        attachment.getFullPath());
                        break;
                    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (IOException ignored)
                {
                }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (IOException ignored)
            {
            }
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (IOException e) {
			throw new LoginException(e.toString());
		}
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException ex) {
                        LOG.error(ex);
                    }
3
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (IOException e) {
			throw new LoginException(e.toString());
		}
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) ParseException 9 
            
// in java/org/tigris/scarab/attribute/DateAttribute.java
catch (ParseException e)
        {
            // Will return the same value
        }
            
// in java/org/tigris/scarab/attribute/DateAttribute.java
catch (ParseException e)
        {
        	// Will return the same value
        }
            
// in java/org/tigris/scarab/screens/admin/ActivityList.java
catch (ParseException e)
            {
                // try the next one
            }
            
// in java/org/tigris/scarab/util/xmlissues/BaseDate.java
catch (ParseException e)
            {
                if (haveFormat)
                {
                    // When a format was explicitly specified,
                    // propogate any parsing problems.
                    throw e;
                }
            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }
3
            
// in java/org/tigris/scarab/util/xmlissues/BaseDate.java
catch (ParseException e)
            {
                if (haveFormat)
                {
                    // When a format was explicitly specified,
                    // propogate any parsing problems.
                    throw e;
                }
            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }
(Lib) NoRowsException 7 
            
// in java/org/tigris/scarab/om/Transition.java
catch (NoRowsException e)
        {
            //Nothing to do, just ignore it
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (NoRowsException e)
            {
                //Nothing to do, just ignore it
            }
            
// in java/org/tigris/scarab/om/Transition.java
catch (NoRowsException e)
        {
            //Nothing to do, just ignore it
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (NoRowsException e)
        {
            // ignore and return null, if the rmit does not exist
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (NoRowsException e)
        {
            // Nothing to do. Ignore.
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (NoRowsException e)
            {
                // No error.
            }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (NoRowsException e) {
                    log.error("No Rows exception when sorting IssueTypeOptions.",e);
                }
0
(Lib) DataBackendException 6 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (DataBackendException e)
            {
                log.error("authenticateNtlm: " + e);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (DataBackendException e)
                                {
                                    // maybe the role request was approved 
                                    // by another admin?
                                    AccessControlList acl = su.getACL();
                                    if (acl.hasRole( role, (Group) module ) )
                                    {
                                        hasRoles = true;
                                    }
                                    else
                                    {
                                        // Something went wrong, ignore for now.
                                    }
                                }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (DataBackendException e)
    		{
    			Log.get().error("hasRoleInModule: " + e);
    		}
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
            
// in java/org/tigris/scarab/actions/Login.java
catch (DataBackendException e)
        {
            setAlertMessage(scarabR, L10NKeySet.ExceptionDatabaseGenericError);
            Log.get().error("Error while attempting to log in", e);
            failAction(data, "Login.vm");
            return null;
        }
2
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
(Lib) MissingResourceException 5 
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (MissingResourceException noKey)
        {
            // No need for logging (already done in base class).
            value = null;
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (MissingResourceException noKey)
        {
            value = null;
        }
            
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		}
            
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		}
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (MissingResourceException e)
                            {
                                Log.get().debug("Missing database initialization "
                                                + "resource: " + e.getMessage());
                            }
0
(Lib) NumberFormatException 5 
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (NumberFormatException noIssueType)
            {
            }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
catch( NumberFormatException e)
        {
            return null;
        }
            
// in java/org/tigris/scarab/attribute/IntegerAttribute.java
catch(NumberFormatException nfe)
            {
                Log.get().warn("non integer string in VALUE field for IntegerAttribute");
            }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
catch (NumberFormatException nfe) // new Integer(issueId) above could fail
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.BadIntegerConversion);
        }
            
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
catch (NumberFormatException nfe)
                    {
                        pref.setInternalAttribute(ids[i]);
                        orderMap.put(pref.getInternalAttribute(), order);
                    }
0
(Lib) TooManyRowsException 5 
            
// in java/org/tigris/scarab/om/Transition.java
catch (TooManyRowsException e)
        {
            //Nothing to do, just ignore it
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TooManyRowsException e)
            {
                //Nothing to do, just ignore it
            }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TooManyRowsException e)
        {
            //Nothing to do, just ignore it
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TooManyRowsException e)
        {
            // Nothing to do. Ignore.
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TooManyRowsException e) {
                    log.error("Too many rows when sorting IssueTypeOptions.",e);
                }
0
(Lib) EntityExistsException 4 
            
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("RoleExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
            
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (EntityExistsException e) {
                }
0
(Lib) RuntimeException 4 
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (RuntimeException exc)
        {
            error = exc;
            throw exc;
        }
4
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (RuntimeException exc)
        {
            error = exc;
            throw exc;
        }
(Lib) UnknownEntityException 4 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (UnknownEntityException e)
            {
                log.error("authenticateNtlm: " + e);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
            
// in java/org/tigris/scarab/actions/Login.java
catch (UnknownEntityException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().info("Invalid login attempted: " + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
1
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
(Lib) NamingException 3 
            
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
catch (NamingException e) {
				logger.error("NamingException caught: ", e);
			}
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (NamingException e) {
				log.error("NamingException caught synchronizing accounts: ",e);
			}
1
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
(Lib) RESyntaxException 3 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException e)
        {
            getLog().error("Could not compile regex: " + regex, e);
            try
            {
                rep = rec.compile(REGEX_PREFIX + REGEX_SUFFIX);
            }
            catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
0
(Lib) TurbineSecurityException 3 
            
// in java/org/tigris/scarab/actions/ForgotPassword.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
            
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
catch (TurbineSecurityException tse)
	            {
	                scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
	            }
            
// in java/org/tigris/scarab/actions/Login.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionTurbineGeneric,e);
            setAlertMessage(scarabR,msg);
            failAction(data, "Login.vm");
            return false;
        }
0
(Lib) ConversionException 2 
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch( ConversionException ce)
        {
            // This happens, if the Turbine Property contains data, which can
            // not be converted to a String. This has been seen on JBOSS.
            // Note: getProperty() does not resolve ${} values, so it is not an
            // option to use it instead of getString(). But in the case of
            // non convertible objects, getProperty().toString() is the best bet.
            // In my opinion this should be handled inside of Configuration, 
            // or at least we should be given a test method Configuration.isString(key)
            // So we could avoid this stuff here...
            // just my 2 cents. (hussayn dabbous)
            result = getTurbineConfiguration().getProperty(key).toString();
        }
            
// in java/org/tigris/scarab/actions/admin/AppConfigurationSettings.java
catch( ConversionException ce)
            {
            	// This happens, if the Turbine Property is not a String.
            	// This has been seen on JBOSS. Since we can't provide any
            	// reasonable value here, ignore the entry and continue.
            	log.warn("Turbine property ["+realKey+"] is not a String value. No update done. (continue)");
            	turbineValue = null;
            }
0
(Lib) LoginException 2 
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (LoginException e) {
            log.error(
                "Unable to create LDAP jaas login context. Forget to add jaas config to JVM? Try adding -Djava.security.auth.login.config=jaas.conf to servlet container.");
            log.error(e);
        }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (LoginException e) {
            cbh.clearPassword();
            log.info(e);

            return null;
        }
0
(Lib) PasswordMismatchException 2 
            
// in java/org/tigris/scarab/actions/ChangePassword.java
catch (PasswordMismatchException pme)
                {
                    scarabR.setAlertMessage(l10n.getMessage(pme));
                    setTarget(data, template);
                }
            
// in java/org/tigris/scarab/actions/Login.java
catch (PasswordMismatchException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().debug("Password mis-match during login attempt: "
                           + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
0
(Lib) SAXException 2 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Domain) ValidationException 2 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException ve)
        {
            throw ve;
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
2
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException ve)
        {
            throw ve;
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
(Lib) AddressException 1 
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch( AddressException e)
        {
            return false;
        }
0
(Lib) ArrayIndexOutOfBoundsException 1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
1
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
(Lib) ClassCastException 1 
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
1
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
(Lib) ClassNotFoundException 1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
1
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
(Lib) DataSetException 1 
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }
1
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }
(Lib) EmailException 1 
            
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
1
            
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
(Lib) Error 1 
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Error err)
        {
            error = err;
            throw err;
        }
1
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Error err)
        {
            error = err;
            throw err;
        }
(Lib) FeedException 1 
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
0
(Lib) FileNotFoundException 1 
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
1
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
(Lib) IllegalAccessException 1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
1
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
(Lib) IllegalArgumentException 1 
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
0
(Domain) IncompatibleMITListException 1 
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (IncompatibleMITListException e)
        {
            scarabR.setAlertMessage(L10NKeySet.IncompatibleMITListReport);
            setTarget(data, "reports,XModuleList.vm");
        }
0
(Lib) InstantiationException 1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
1
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
(Lib) IntrospectionException 1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) JDOMException 1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) NoSuchElementException 1 
            
// in java/org/tigris/scarab/om/ActivitySet.java
catch (NoSuchElementException nsee)
                        {
                            Throwable th = new Throwable("No such element exception occured.(ignore and assume transitionToSealed=false)");
                            th.printStackTrace();
                            result = false;
                        }
0
(Lib) NotActiveException 1 
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (java.io.NotActiveException e)
        {
        }
0
(Lib) NullPointerException 1 
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (NullPointerException npe)
            {
                // Something wrong in the database ?
                displayValue="";
            }
0
(Lib) ParserConfigurationException 1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) SAXParseException 1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }
0
(Domain) ScarabLocalizedTorqueException 1 
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabLocalizedTorqueException slte) 
                        {
                            String msg = slte.getMessage(l10n);
                            scarabR.setAlertMessage(msg);
                        }
0
(Lib) SchedulerException 1 
            
// in java/org/tigris/scarab/notification/NotificationManagerJob.java
catch (SchedulerException e) {
			log.error("execute(): " + e);
		}
0
(Lib) ServletException 1 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (ServletException e)
                {
                    log.error("authenticateNtlm: " + e);
                }
0
(Lib) SmbAuthException 1 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (SmbAuthException sae)
            {
                response.setHeader("WWW-Authenticate", "NTLM");
                response.setHeader("Connection", "close");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.flushBuffer();
                return;
            }
0
(Lib) TransformerException 1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) UnsupportedCallbackException 1 
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}
1
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}

Exception Recast Summary

There is a common practice of throwing exceptions from within a catch block (e.g. for wrapping a low-level exception). The following table summarizes the usage of this practice in the application. The last column gives the number of times it happens for a pair of exceptions. The graph below the table graphically renders the same information. For a given node, its color represents its origin (blue means library exception, orange means domain exception); the left-most number is the number of times it is thrown, the right-most is the number of times it is caught.

Catch Throw
(Lib) Exception
(Lib) TurbineException
(Lib) RuntimeException
(Lib) TorqueException
(Domain) ScarabException
(Lib) TorqueRuntimeException
(Domain) ScarabLocalizedTorqueException
(Lib) Exception
(Lib) InitializationException
(Lib) EmailException
(Domain) ScarabRuntimeException
(Lib) DataBackendException
(Lib) BuildException
Unknown
2 
                    
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
                    
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
20 
                    
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e) {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
                    
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
                    
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/om/ScarabUserManager.java
catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
                    
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
                    
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
                    
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
                    
// in java/org/tigris/scarab/feeds/IssueFeed.java
catch( Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
            {
                throw new RuntimeException(e);
            }
                    
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
                    
// in java/org/tigris/scarab/util/ScarabUtil.java
catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
                    
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
14 
                    
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                throw new TorqueException(e);
            }
                    
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
                    
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
                    
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
                    
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
                    
// in java/org/tigris/scarab/om/Attachment.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/om/AttributeValuePeer.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
12 
                    
// in java/org/tigris/scarab/om/MITList.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
                    
// in java/org/tigris/scarab/om/MITList.java
catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
                    
// in java/org/tigris/scarab/om/ROptionOption.java
catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
                    
// in java/org/tigris/scarab/om/MITListItem.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
                    
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
                    
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                    
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                    
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
                    
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
1 
                    
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
3 
                    
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
                    
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
                    
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
1 
                    
// in java/org/tigris/scarab/actions/ModifyModule.java
catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
6 
                    
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/services/TorqueService.java
catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }
                    
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
3 
                    
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }
                    
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }
                    
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
7 
                    
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
                    
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
                    
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
                    
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
                    
// in java/org/tigris/scarab/services/cache/ScarabCache.java
catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
                    
// in java/org/tigris/scarab/util/ComponentLocator.java
catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
                    
// in java/org/tigris/scarab/util/word/SearchFactory.java
catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
4 
                    
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
                    
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
3 
                    
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
		{
		e.printStackTrace(); throw e; //EXCEPTION
		}
                    
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
                    
// in java/org/tigris/scarab/actions/ModifyModule.java
catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
(Lib) TorqueException
(Lib) TurbineException
(Lib) RuntimeException
(Lib) TorqueRuntimeException
(Domain) ScarabRuntimeException
(Domain) ScarabLocalizedTorqueException
(Domain) ScarabException
Unknown
1 
                    
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
9 
                    
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
                    
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
1 
                    
// in java/org/tigris/scarab/om/MITList.java
catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
1 
                    
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
1 
                    
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
9 
                    
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
                    
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
                    
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }
                    
// in java/org/tigris/scarab/om/ActivitySet.java
catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
                    
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
                    
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
                    
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
                    
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
3 
                    
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw e;
        }
                    
// in java/org/tigris/scarab/search/CachedQuery.java
catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
                    
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
(Domain) ScarabException
(Domain) ScarabException
(Lib) RuntimeException
Unknown
1 
                    
// in java/org/tigris/scarab/om/Issue.java
catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
1 
                    
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (ScarabException e) {
                throw new RuntimeException(e);
            }
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
(Domain) ValidationException
Unknown
2 
                    
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException ve)
        {
            throw ve;
        }
                    
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
(Lib) RuntimeException
Unknown
4 
                    
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                    
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                    
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                    
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (RuntimeException exc)
        {
            error = exc;
            throw exc;
        }
(Lib) IOException
(Lib) LoginException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (IOException e) {
			throw new LoginException(e.toString());
		}
2 
                    
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) DataBackendException
(Lib) TorqueException
Unknown
1 
                    
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
1 
                    
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
(Lib) UnknownEntityException
(Lib) TorqueException
1 
                    
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
(Lib) ParseException
(Domain) ScarabException
Unknown
2 
                    
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
                    
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }
1 
                    
// in java/org/tigris/scarab/util/xmlissues/BaseDate.java
catch (ParseException e)
            {
                if (haveFormat)
                {
                    // When a format was explicitly specified,
                    // propogate any parsing problems.
                    throw e;
                }
            }
(Lib) SAXException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) ClassCastException
(Lib) RuntimeException
1 
                    
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
(Lib) Error
Unknown
1 
                    
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Error err)
        {
            error = err;
            throw err;
        }
(Lib) InstantiationException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
(Lib) IllegalAccessException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
(Lib) ClassNotFoundException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
(Lib) EmailException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
(Lib) NamingException
(Lib) LoginException
1 
                    
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
(Lib) UnsupportedCallbackException
(Lib) LoginException
1 
                    
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}
(Lib) FileNotFoundException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
(Lib) ParserConfigurationException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) TransformerException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) IntrospectionException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) JDOMException
(Domain) ScarabException
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
(Lib) ArrayIndexOutOfBoundsException
Unknown
1 
                    
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
(Lib) DataSetException
(Lib) RuntimeException
1 
                    
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }

Caught / Thrown Exception

Not all exceptions are thrown AND caught in the same project. The following table gives the exceptions types with respect to this. The lower left hand side sell lists all exceptions thrown but not caught (prevalent for libraries), the upper right-hand side lists all exceptions caught but not thrown (usually coming from external dependencies).

Thrown Not Thrown
Caught
Type Name
(Lib) Exception
(Lib) TorqueException
(Domain) ScarabLocalizedTorqueException
(Domain) IncompatibleMITListException
(Domain) ScarabException
(Domain) ValidationException
(Lib) RuntimeException
(Lib) ServletException
(Lib) DataBackendException
(Lib) UnknownEntityException
(Lib) IllegalArgumentException
(Lib) ParseException
(Lib) NullPointerException
(Lib) TurbineSecurityException
(Lib) ClassCastException
(Lib) NoSuchElementException
(Lib) EntityExistsException
(Lib) Error
(Lib) EmailException
(Lib) LoginException
(Lib) UnsupportedCallbackException
(Lib) ArrayIndexOutOfBoundsException
Type Name
(Lib) NumberFormatException
(Lib) IOException
(Lib) SmbAuthException
(Lib) MissingResourceException
(Lib) ConversionException
(Lib) NoRowsException
(Lib) TooManyRowsException
(Lib) SAXException
(Lib) RESyntaxException
(Lib) AddressException
(Lib) NotActiveException
(Lib) SchedulerException
(Lib) FeedException
(Lib) PasswordMismatchException
(Lib) InstantiationException
(Lib) IllegalAccessException
(Lib) ClassNotFoundException
(Lib) NamingException
(Lib) FileNotFoundException
(Lib) ParserConfigurationException
(Lib) TransformerException
(Lib) IntrospectionException
(Lib) JDOMException
(Lib) SAXParseException
(Lib) DataSetException
Not caught
Type Name
(Lib) TurbineException
(Lib) IndexOutOfBoundsException
(Lib) IllegalStateException
(Lib) TorqueRuntimeException
(Lib) UnsupportedOperationException
(Domain) ScarabRuntimeException
(Domain) ScarabUpdateException
(Lib) InitializationException
(Lib) ServiceException
(Lib) BuildException

Methods called in Catch and Finally Blocks

The following shows the methods that are called inside catch blocks (first column) and finally blocks (second column). For each method, we give the number of times it is called in a catch block (second sub-column), and the total number of calls (third sub-column). If the method name is red, it means that it is only called from catch/finally blocks. Hovering over a number triggers showing code snippets from the application code.

Catch Finally
Method Nbr Nbr total
error 155 
                  
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }
                  
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (IOException e)
                {
                    log.error("authenticateNtlm: " + e);
                }
                  
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (ServletException e)
                {
                    log.error("authenticateNtlm: " + e);
                }
                  
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (DataBackendException e)
            {
                log.error("authenticateNtlm: " + e);
            }
                  
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (UnknownEntityException e)
            {
                log.error("authenticateNtlm: " + e);
            }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Could not get list attributes", e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // system would be messed up, if we are here.  Punt
            nextTemplate = "Index.vm";
            setAlertMessage(L10NKeySet.CannotDetermineIssueEntryTemplate);
            Log.get().error("CannotDetermineIssueEntryTemplate", e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Problem getting user list", e);
            list = new ScarabPaginatedList();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            hasPermission = false;
            Log.get().error("Permission check failed on:" + permission, e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            hasPermission = false;
            Log.get().error("Permission check failed on:" + permission, e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
            {
                Log.get().error(obj + " cannot convert to an integer.", e);
            }
                  
// in java/org/tigris/scarab/om/Activity.java
catch (Exception e)
            {
                getLog().error("Activity.getAttachment(): ", e);
            }
                  
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
            {
                getLog().error(e);
                dispVal = "!Error-Check Logs!";
            }
                  
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
                  
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
            {
                getLog().error(e);
                dispVal = "!Error-Check Logs!";
            }
                  
// in java/org/tigris/scarab/om/NotificationStatusPeer.java
catch (TorqueException e) 
        {
			log.error("getPendingNotifications(): " + e);
		}
                  
// in java/org/tigris/scarab/om/NotificationStatusPeer.java
catch (TorqueException e) 
        {
            log.error("getPendingNotifications(): " + e);
        }
                  
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
catch (TorqueException e)
        {
            Log.get().error("setInternalAttribute(): " + e);
        }
                  
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
catch (TorqueException e)
        {
            getLog().error("getName(): " + e);
        }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                getLog().error("Error getting HTTP_DOMAIN:", e);
            }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                getLog().error("Error getting DOMAIN_NAME:", e);
            }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
        {
            getLog().error("isIssueReasonRequired(): " + te);
        }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
                getLog().error("isIssueReasonVisible(): " + te);
            }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
        {
            getLog().error("isIssueReasonRequiredInherited(): " + te);
        }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            getLog().error("getCommentRenderingEngine(): " + e);
        }
                  
// in java/org/tigris/scarab/om/NotificationStatus.java
catch (TorqueException te)
        {
            getLog().error("setActivity(): Cannot find activity's issue!: " + te);
        }
                  
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch (TorqueException e)
            {
                Log.get().error("", e);
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch (Exception e) 
            {
                Log.get().error("", e);
                // return null
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
            {
                e.printStackTrace();
                getLog().error(e);
                return null;
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException e)
        {
            getLog().error("Could not compile regex: " + regex, e);
            try
            {
                rep = rec.compile(REGEX_PREFIX + REGEX_SUFFIX);
            }
            catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
        }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
                  
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
                  
// in java/org/tigris/scarab/om/TransitionPeer.java
catch (TorqueException e) {
			log.error("getTransitions(): AttributeOption: " + fromOption.getOptionId() + ": " + e);
		}
                  
// in java/org/tigris/scarab/om/NotificationRulePeer.java
catch (TorqueException e) {
                log.error("getPendingNotifications(): " + e);
            }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            getLog().error("Problem determining whether issue is template");
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
                  
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            getLog().error(e);
                            e.printStackTrace();
                        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            Log.get().error("Unable to retrieve user for "
                                            + "attribute", e);
                        }
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e)
            {
                getLog().error("An exception prevented retrieving any modules", e);
            }
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception te)
        {
            getLog().error("getAssignIssuesList(): " + te);
        }
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e) {
    			Log.get().error(e);
			}
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (DataBackendException e)
    		{
    			Log.get().error("hasRoleInModule: " + e);
    		}
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old issues.  "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old reports.  "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (TorqueException e)
                    {
                        Log.get().error("Unable to sort on module names", e);
                    }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old MIT lists.  "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old queries.  "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing entered issue types. "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
            {
                getLog().error("Error getting the issue type name: ", e);
            }
                  
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
            {
                getLog().error("Error getting the issue type description: ", e);
            }
                  
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
                  
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
                  
// in java/org/tigris/scarab/notification/NotificationManagerJob.java
catch (SchedulerException e) {
			log.error("execute(): " + e);
		}
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                    {
                        log.error("queueNotifications(): while processing activity queue: " + e.getMessage(),e);
                        logNotificationData(notification);
                        log.error("queueNotifications(): Abort this run");
                        break;
                    }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
        {
            log.error("queueNotifications(): while setting up the activity queue: " + e.getMessage(),e);
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(Exception e)
        {
            log.error("queueNotifications(): while dumping notificationData: " + e.getMessage(),e);
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
            {
                log.error("sendPendingNotifications(): No access to Issue [" + te + "]");
                // Can not proceed with this issue !
                continue;
            }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
                {
                    log.error("sendPendingNotifications(): No access to current Scarab User" + te);
                    // We can continue processing here. We just don't know how to process Emails
                    // for the current user.
                }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                    {
                        exception = e;
                        log.error("Failed to send email :" + e);
                    }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                {
                    log.error("sendPendingNotifications(): Updating: " + e, e);
                }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
            {
                log.error("sendPendingNotifications(): " + te);
                continue;
            }
                  
// in java/org/tigris/scarab/notification/NotificationManagerFactory.java
catch (Exception e)
            {
                log
                        .error("Could not instantiate notification manager '"
                                + classname + "'. Defaulting to '"
                                + ScarabNotificationManager.class.getName()
                                + "': " + e);
                instance = new ScarabNotificationManager();
            }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("addAttributeOption(String, String) -  : attr=" + attr 
                    + ", opt=" + opt + ", rslt=" + rslt, e);

            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", options=" + options + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (NoRowsException e) {
                    log.error("No Rows exception when sorting IssueTypeOptions.",e);
                }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TooManyRowsException e) {
                    log.error("Too many rows when sorting IssueTypeOptions.",e);
                }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TorqueException e) {
                    log.error("Torque exception when sorting IssueTypeOptions.",e);
                }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/ModuleSwitchingLink.java
catch (Exception e)
        {
            Log.get().error("Could not determine homepage", e);
            homePage = "Index.vm";
        }
                  
// in java/org/tigris/scarab/actions/ForgotPassword.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }
                  
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
catch (TorqueException e)
        {
            log().error("deleteRoleRequests: " + e); 
        }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                            {
                                log().error("Error adding attribute option:", e);
                                scarabR.setAlertMessage("Error adding attribute option:" + l10n.getMessage(e));
                            }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (TorqueException te)
            {
                this.log().error("doSavetransitiondata(): " + te);
            }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (TorqueException te)
        {
            this.log().error("doDeleteTransition(): " + te);
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (DataBackendException e)
        {
            setAlertMessage(scarabR, L10NKeySet.ExceptionDatabaseGenericError);
            Log.get().error("Error while attempting to log in", e);
            failAction(data, "Login.vm");
            return null;
        }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            s = "ERROR! on " + super.toString();
            Log.get().error("", e);
        }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                Log.get().error("Error on Attribute Id=" + attId, e);
                return "Error on Attribute Id=" + attId;
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Attribute Id=" + attId;
                Log.get().error(result, e);
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Attribute Id=" + attId;
                Log.get().error(result, e);
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Option Id=" + optionId;
                Log.get().error(result, e);
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Option Id=" + optionId;
                Log.get().error(result, e);
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            result = "Error on Option Id=" + rua.getUserId();
            Log.get().error(result, e);
        }
                  
// in java/org/tigris/scarab/reports/ReportBridge.java
catch (Exception e)
        {
            result = false;
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
        {
            Log.get(this.getClass().getName())
                    .error("canMakeTransition: " + te);
        }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (Exception e) {
            Log.get().error("filterConditionalTransitions: " + e);
        }
                  
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch(Exception ex)
        {
            log.error("Double error: Can not dump Email context. ("+ex.getMessage()+")");
            log.error("key["+keystring+"]");
            log.error("val["+val+"]");
        }
                  
// in java/org/tigris/scarab/services/TorqueService.java
catch (TorqueException te)
        {
            Log.get("org.apache.fulcrum").error("TorqueService.shutdown(): " + te);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
catch (NamingException e) {
				logger.error("NamingException caught: ", e);
			}
                  
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
catch (Exception e) {
				logger.error("Exception caught: ", e);
			}
                  
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (NamingException e) {
				log.error("NamingException caught synchronizing accounts: ",e);
			}
                  
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (LoginException e) {
            log.error(
                "Unable to create LDAP jaas login context. Forget to add jaas config to JVM? Try adding -Djava.security.auth.login.config=jaas.conf to servlet container.");
            log.error(e);
        }
                  
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (TorqueException e) {
            log.error(e);

            return null;
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException ex) {
                        LOG.error(ex);
                    }
                  
// in java/org/tigris/scarab/util/SnippetRenderer.java
catch (Exception e)
        {
            LOG.error("Error rendering " + template + ". ", e);
            result = "ERROR!";
        }
                  
// in java/org/tigris/scarab/util/IssueIdParser.java
catch (Exception e)
        {
            Log.get().error("An npe is going to occur because I could not " +
                            "compile regex: [:alpha:]*\\d+", e);
        }
                  
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch( Exception e)
        {
            analyzer = new PorterStemAnalyzer();
            Log.get().error("Could not create Lucene Analyzer (" + analyzerClassName + "), using default.", e);
        }
                  
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
                  
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
        {
            log.error("Error rendering subject for " + template + ". ", e);
            result = "Scarab System Notification";
        }
                  
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
            {
                log.error(
                        "Couldn't determine locale for user " + user
                                .getUserName(), e);
            }
184
get 131 
                  
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }
                  
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
                  
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Could not get list attributes", e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
            {
                Log.get().info("[ScarabRequestTool] Unable to retrieve Module: " +
                         key, e);
            }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // system would be messed up, if we are here.  Punt
            nextTemplate = "Index.vm";
            setAlertMessage(L10NKeySet.CannotDetermineIssueEntryTemplate);
            Log.get().error("CannotDetermineIssueEntryTemplate", e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Problem getting user list", e);
            list = new ScarabPaginatedList();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            hasPermission = false;
            Log.get().error("Permission check failed on:" + permission, e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            hasPermission = false;
            Log.get().error("Permission check failed on:" + permission, e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().debug("Error: ", e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabUserTool.java
catch (Exception e)
        {
            // Logged at debug level, as a null user is interpreted
            // as an invalid user name
            Log.get().debug("User, "+username+" could not be found,", e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
        {
            // return the text as is and log the error
            result = new ArrayList(1);
            result.add(text);
            Log.get().warn("Could not linkify text: " + text, e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
            {
                Log.get().error(obj + " cannot convert to an integer.", e);
            }
                  
// in java/org/tigris/scarab/search/CachedQuery.java
catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
                  
// in java/org/tigris/scarab/attribute/IntegerAttribute.java
catch(NumberFormatException nfe)
            {
                Log.get().warn("non integer string in VALUE field for IntegerAttribute");
            }
                  
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
        {
            sb.append("Error retrieving list items. see logs.");
            Log.get().warn("", e);
        }
                  
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
catch (TorqueException e)
        {
            Log.get().error("setInternalAttribute(): " + e);
        }
                  
// in java/org/tigris/scarab/om/IssueType.java
catch(IOException ioe)
            {
                Log.get().warn("Exception while loading the file: IssueTypeConfig.properties", ioe);
            }
                  
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
            {
                Log.get().warn("Error accessing dedupe sequence for issue "
                               + "type '" + this + '\'', e);
                return sequence;
            }
                  
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
        {
            Log.get().warn("Could not get RIA records for " + getName(), e);
        }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch (TorqueException e)
            {
                Log.get().error("", e);
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch (Exception e) 
            {
                Log.get().error("", e);
                // return null
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
                  
// in java/org/tigris/scarab/om/AttributeGroupManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid AttributeGroup id ", e);
            }
                  
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            Log.get().error("Unable to retrieve user for "
                                            + "attribute", e);
                        }
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e) {
    			Log.get().error(e);
			}
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (DataBackendException e)
    		{
    			Log.get().error("hasRoleInModule: " + e);
    		}
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old issues.  "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old reports.  "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            Log.get().warn("Error determining user homepage", e);
        }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().warn("Could not determine query target.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (TorqueException e)
                    {
                        Log.get().error("Unable to sort on module names", e);
                    }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old MIT lists.  "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old queries.  "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing entered issue types. "
                                + "This could be a memory leak.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                final L10NKey msg = new L10NKey("ErrorPossibleMemoryLeak");
                Log.get().warn(msg.getMessage(), e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            // I think it might be ok to return null from this method
            // but until that is investigated return the default in
            // event of error
            result = ScarabConstants.DEFAULT_LOCALE;
            Log.get().warn(
                "AbstractScarabUser.getLocale() could not "
                    + "retrieve locale for user id="
                    + getUserId()
                    + "; Error message: "
                    + e.getMessage());
        }
                  
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
                  
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
                  
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
        {
            Log.get().warn("Can not access Database while processing wakeupOnHoldTimeouts");
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
        {
            Log.get().warn("Can not access Database while processing wakeupOnHoldTimeouts");
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
        {
            Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
            Log.get().warn("db layer reported: ["+e.getMessage()+"]");
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
            {
                Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                Log.get().warn("db layer reported: ["+e.getMessage()+"]");
            }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
                {
                    Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                    Log.get().warn("db layer reported: ["+e.getMessage()+"]");
                }
                  
// in java/org/tigris/scarab/screens/ViewAttachment.java
catch (java.io.IOException ioe)
                    {
                        Log.get().debug("File download was aborted: " + 
                                        attachment.getFullPath());
                        break;
                    }
                  
// in java/org/tigris/scarab/screens/ReportExport.java
catch (Exception e)
        {
            printer.print(l10n.get("ErrorOccurredCheckingMessage"));
        }
                  
// in java/org/tigris/scarab/screens/SaveTemplate.java
catch (Exception e)
        {
            title = l10n.get("SaveTemplate");
            Log.get().debug("no current issue type, cannot retrieve SaveTemplate title", e);
        }
                  
// in java/org/tigris/scarab/screens/Default.java
catch (Exception e)
            {
                Log.get().info(
                    "Error getting page title for Screen: " + data.getTarget());
            }
                  
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
catch (Exception e)
                {
                    resultCode = RESULT_ERROR_EXCEPTION;
                    // TODO: Improve localizability of this text.
                    resultString = l10n.get("ProcessingErrors") + ": "
                        + e.getMessage();
                }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/ModuleSwitchingLink.java
catch (Exception e)
        {
            Log.get().error("Could not determine homepage", e);
            homePage = "Index.vm";
        }
                  
// in java/org/tigris/scarab/screens/MoveIssue.java
catch (Exception e)
        {
            title = "Error; Copy or Move?";
            Log.get().warn("Error determining title", e);
        }
                  
// in java/org/tigris/scarab/actions/ForgotPassword.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
                {
                    // would probably be a hack of the form
                    scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                    Log.get().debug("", e);
                    return;
                }
                  
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.InvalidId);
            Log.get().warn("An invalid id was entered: "+listId);
        }
                  
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
                  
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
catch (Exception e)
                            {
                                scarabR.setAlertMessage(
                                    l10n.get("CannotDeleteIssueType"));
                                Log.get().warn(
                                    "Could not delete issue type", e);
                            }
                  
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
catch (Exception e)
               {
                   scarabR.setAlertMessage(l10n.get(NO_PERMISSION_MESSAGE));
               }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                        {
                            scarabR.setAlertMessage(
                               l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabException e)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(e));
                        Log.get().warn(
                            "This is an application error, if it is not permission related.", e);
                    }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    // we do not want any exception thrown here to affect
                    // the user experience, it is just considered a 
                    // non-detectable file type.  But still the exception is
                    // not expected, so log it.
                    mimeAField.setMessage("intake_CouldNotDetermineMimeType");
                    Log.get().info(
                        "Could not determine mimetype of uploaded file.", e);
                }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
        {
            type.setMessage(l10n.get(L10NKeySet.SelectRelation));
            return false;
        }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    // it will error out if they attempt to delete
                    // a dep via a child dep.
                    String l10nKey = se.getMessage();
                    scarabR.setAlertMessage(l10n.get(l10nKey));
                }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (UnknownEntityException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().info("Invalid login attempted: " + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (PasswordMismatchException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().debug("Password mis-match during login attempt: "
                           + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (DataBackendException e)
        {
            setAlertMessage(scarabR, L10NKeySet.ExceptionDatabaseGenericError);
            Log.get().error("Error while attempting to log in", e);
            failAction(data, "Login.vm");
            return null;
        }
                  
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
            {
                L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
                scarabR.setAlertMessage(l10nMessage);
                Log.get().warn("Exception during issue copy/move", e);
                return;
            }
                  
// in java/org/tigris/scarab/reports/ReportHeading.java
catch (Exception e)
                {
                    Log.get().warn("Error on attribute id", e);
                    result = false;
                }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            s = "ERROR! on " + super.toString();
            Log.get().error("", e);
        }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                Log.get().error("Error on Attribute Id=" + attId, e);
                return "Error on Attribute Id=" + attId;
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Attribute Id=" + attId;
                Log.get().error(result, e);
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Attribute Id=" + attId;
                Log.get().error(result, e);
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Option Id=" + optionId;
                Log.get().error(result, e);
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Option Id=" + optionId;
                Log.get().error(result, e);
            }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            result = "Error on Option Id=" + rua.getUserId();
            Log.get().error(result, e);
        }
                  
// in java/org/tigris/scarab/reports/ReportBridge.java
catch (Exception e)
        {
            result = false;
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
        {
            Log.get(this.getClass().getName())
                    .error("canMakeTransition: " + te);
        }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (Exception e) {
            Log.get().error("filterConditionalTransitions: " + e);
        }
                  
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (MissingResourceException e)
                            {
                                Log.get().debug("Missing database initialization "
                                                + "resource: " + e.getMessage());
                            }
                  
// in java/org/tigris/scarab/services/TorqueService.java
catch (TorqueException te)
        {
            Log.get("org.apache.fulcrum").error("TorqueService.shutdown(): " + te);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
                  
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not parse port number", e);
        }
                  
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not get scheme parameter", e);
        }
                  
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not get script name parameter", e);
        }
                  
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            allowed = false;
            Log.get().info("Could not check permission due to: ", e);
        }
                  
// in java/org/tigris/scarab/util/IssueIdParser.java
catch (Exception e)
        {
            Log.get().error("An npe is going to occur because I could not " +
                            "compile regex: [:alpha:]*\\d+", e);
        }
                  
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + className + '\'', e);
            }
                  
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + linkClass.getName() + 
                               "'; will use default link tool.", e);
                result = new ErrorEmailLink(module);            
            }
                  
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch( Exception e)
        {
            analyzer = new PorterStemAnalyzer();
            Log.get().error("Could not create Lucene Analyzer (" + analyzerClassName + "), using default.", e);
        }
                  
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
                  
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
            {
                Log.get().debug(e);
            }
                  
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
        {
            Log.get().debug(e);
        }
                  
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
        {
            Log.get().debug(e);
        }
1227
setAlertMessage 55 
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // system would be messed up, if we are here.  Punt
            nextTemplate = "Index.vm";
            setAlertMessage(L10NKeySet.CannotDetermineIssueEntryTemplate);
            Log.get().error("CannotDetermineIssueEntryTemplate", e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
            {
                setAlertMessage(L10NKeySet.InvalidId);
            }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            setAlertMessage(L10NKeySet.InvalidIssueId);
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (ScarabException e)
        {
            setAlertMessage(e.getL10nMessage());
        }
                  
// in java/org/tigris/scarab/screens/admin/ViewXMLExportIssues.java
catch (Exception e)
                {
                    data.setTarget("admin,XMLExportIssues.vm");
                    scarabR.setAlertMessage(l10n.getMessage(e));
                    return;
                }
                  
// in java/org/tigris/scarab/actions/Search.java
catch(Exception e)
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneral,e);
                    scarabR.setAlertMessage(msg);
                }
                  
// in java/org/tigris/scarab/actions/ForgotPassword.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
                  
// in java/org/tigris/scarab/actions/TemplateList.java
catch (ScarabException e)
                {
                    success = false;
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
                  
// in java/org/tigris/scarab/actions/TemplateList.java
catch (Exception e)
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.getMessage(e));
                }
                  
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (IncompatibleMITListException e)
        {
            scarabR.setAlertMessage(L10NKeySet.IncompatibleMITListReport);
            setTarget(data, "reports,XModuleList.vm");
        }
                  
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
                {
                    // would probably be a hack of the form
                    scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                    Log.get().debug("", e);
                    return;
                }
                  
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.InvalidId);
            Log.get().warn("An invalid id was entered: "+listId);
        }
                  
// in java/org/tigris/scarab/actions/ModifyModule.java
catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
                  
// in java/org/tigris/scarab/actions/QueryList.java
catch (Exception e)
               {
                   ScarabLocalizationTool l10n = getLocalizationTool(context);
                   getScarabRequestTool(context).setAlertMessage(NO_PERMISSION_MESSAGE);
               }
                  
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }
                  
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception se)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        return;
                    }
                  
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
catch(Exception e)
                        {
                            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.CouldNotSendNotification,e);
                            scarabR.setAlertMessage(l10nMessage);
                        }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (Exception e)
                    {
                        L10NMessage l10nMessage =new L10NMessage(EMAIL_ERROR,e);
                        scarabR.setAlertMessage(l10nMessage);
                    }
                  
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
catch (Exception e)
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch(Exception e)
                            {
                                Localizable msg = new L10NMessage(L10NKeySet.ExceptionEmailFailure,e);
                                scarabR.setAlertMessage(msg);
                            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
                  
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
catch (Exception e)
                            {
                                scarabR.setAlertMessage(
                                    l10n.get("CannotDeleteIssueType"));
                                Log.get().warn(
                                    "Could not delete issue type", e);
                            }
                  
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
catch (Exception e)
               {
                   scarabR.setAlertMessage(l10n.get(NO_PERMISSION_MESSAGE));
               }
                  
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
catch (Exception e)
               {
                   scarabR.setAlertMessage(ScarabConstants.NO_PERMISSION_MESSAGE);
               }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                        {
                            scarabR.setAlertMessage(
                               l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                            {
                                log().error("Error adding attribute option:", e);
                                scarabR.setAlertMessage("Error adding attribute option:" + l10n.getMessage(e));
                            }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabLocalizedTorqueException slte) 
                        {
                            String msg = slte.getMessage(l10n);
                            scarabR.setAlertMessage(msg);
                        }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (TorqueException te) 
                        {
                            String msg = te.getMessage();
                            scarabR.setAlertMessage(msg);
                        }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabException e)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(e));
                        Log.get().warn(
                            "This is an application error, if it is not permission related.", e);
                    }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (TorqueException e)
                {
                    alreadySubmited = true;
                    scarabR.setAlertMessage(L10NKeySet.ResubmitError);
                }
                  
// in java/org/tigris/scarab/actions/AssignIssue.java
catch(Exception e)
                {
                    L10NMessage l10nMessage = new L10NMessage(EMAIL_ERROR,e);
                    scarabR.setAlertMessage(l10nMessage);
                }
                  
// in java/org/tigris/scarab/actions/AssignIssue.java
catch (NumberFormatException nfe) // new Integer(issueId) above could fail
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.BadIntegerConversion);
        }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception se)
        {
            scarabR.setAlertMessage(l10n.getMessage(se));
        }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
                return;
            }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch(Exception e)
            {
                String l10nMessage = l10n.getMessage(e);
                scarabR.setAlertMessage(l10nMessage);
                return;
            }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    scarabR.setAlertMessage(l10n.getMessage(se));
                }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    // it will error out if they attempt to delete
                    // a dep via a child dep.
                    String l10nKey = se.getMessage();
                    scarabR.setAlertMessage(l10n.get(l10nKey));
                }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    log().debug("Delete error: ", e);
                }
                  
// in java/org/tigris/scarab/actions/ChangePassword.java
catch (PasswordMismatchException pme)
                {
                    scarabR.setAlertMessage(l10n.getMessage(pme));
                    setTarget(data, template);
                }
                  
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
catch (TurbineSecurityException tse)
	            {
	                scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
	            }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionTurbineGeneric,e);
            setAlertMessage(scarabR,msg);
            failAction(data, "Login.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (UnknownEntityException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().info("Invalid login attempted: " + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (PasswordMismatchException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().debug("Password mis-match during login attempt: "
                           + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (DataBackendException e)
        {
            setAlertMessage(scarabR, L10NKeySet.ExceptionDatabaseGenericError);
            Log.get().error("Error while attempting to log in", e);
            failAction(data, "Login.vm");
            return null;
        }
                  
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectModuleAndIssueType);
            return;
        }
                  
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
            {
                L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
                scarabR.setAlertMessage(l10nMessage);
                Log.get().warn("Exception during issue copy/move", e);
                return;
            }
328
log 52 
                  
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
catch (TorqueException e)
        {
            log().error("deleteRoleRequests: " + e); 
        }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                            {
                                log().error("Error adding attribute option:", e);
                                scarabR.setAlertMessage("Error adding attribute option:" + l10n.getMessage(e));
                            }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (TorqueException te)
            {
                this.log().error("doSavetransitiondata(): " + te);
            }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (TorqueException te)
        {
            this.log().error("doDeleteTransition(): " + te);
        }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
            {
                log().debug("Delete error: ", e);
                return false;
            }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    log().debug("Delete error: ", e);
                }
136
warn 43 
                  
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
catch (Exception e)
            {
                LOG.warn(
                    "Could not set locale info for user ["
                        + user.getName()
                        + "]");
            }
                  
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
        {
            // return the text as is and log the error
            result = new ArrayList(1);
            result.add(text);
            Log.get().warn("Could not linkify text: " + text, e);
        }
                  
// in java/org/tigris/scarab/search/CachedQuery.java
catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
                  
// in java/org/tigris/scarab/attribute/IntegerAttribute.java
catch(NumberFormatException nfe)
            {
                Log.get().warn("non integer string in VALUE field for IntegerAttribute");
            }
                  
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
        {
            sb.append("Error retrieving list items. see logs.");
            Log.get().warn("", e);
        }
                  
// in java/org/tigris/scarab/om/IssueType.java
catch(IOException ioe)
            {
                Log.get().warn("Exception while loading the file: IssueTypeConfig.properties", ioe);
            }
                  
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
            {
                Log.get().warn("Error accessing dedupe sequence for issue "
                               + "type '" + this + '\'', e);
                return sequence;
            }
                  
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
        {
            Log.get().warn("Could not get RIA records for " + getName(), e);
        }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
                  
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
                  
// in java/org/tigris/scarab/om/AttributeGroupManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid AttributeGroup id ", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            Log.get().warn("Error determining user homepage", e);
        }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().warn("Could not determine query target.", e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                final L10NKey msg = new L10NKey("ErrorPossibleMemoryLeak");
                Log.get().warn(msg.getMessage(), e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            // I think it might be ok to return null from this method
            // but until that is investigated return the default in
            // event of error
            result = ScarabConstants.DEFAULT_LOCALE;
            Log.get().warn(
                "AbstractScarabUser.getLocale() could not "
                    + "retrieve locale for user id="
                    + getUserId()
                    + "; Error message: "
                    + e.getMessage());
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
        {
            Log.get().warn("Can not access Database while processing wakeupOnHoldTimeouts");
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
        {
            Log.get().warn("Can not access Database while processing wakeupOnHoldTimeouts");
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
        {
            Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
            Log.get().warn("db layer reported: ["+e.getMessage()+"]");
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
            {
                Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                Log.get().warn("db layer reported: ["+e.getMessage()+"]");
            }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
                {
                    Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                    Log.get().warn("db layer reported: ["+e.getMessage()+"]");
                }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TorqueException e) {
                    if (log.isEnabledFor(org.apache.log4j.Priority.WARN)) {
                        log
                                .warn(
                                        "mapAttributeOptionToAllModuleIssueTypes(String, String) - IssueTypeMApping alreadyt exists for this combination : attribute=" + attribute + ", option=" + option + ", it=" + it, null); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                    }
                }
                  
// in java/org/tigris/scarab/screens/MoveIssue.java
catch (Exception e)
        {
            title = "Error; Copy or Move?";
            Log.get().warn("Error determining title", e);
        }
                  
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.InvalidId);
            Log.get().warn("An invalid id was entered: "+listId);
        }
                  
// in java/org/tigris/scarab/actions/admin/AppConfigurationSettings.java
catch( ConversionException ce)
            {
            	// This happens, if the Turbine Property is not a String.
            	// This has been seen on JBOSS. Since we can't provide any
            	// reasonable value here, ignore the entry and continue.
            	log.warn("Turbine property ["+realKey+"] is not a String value. No update done. (continue)");
            	turbineValue = null;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
catch (Exception e)
                            {
                                scarabR.setAlertMessage(
                                    l10n.get("CannotDeleteIssueType"));
                                Log.get().warn(
                                    "Could not delete issue type", e);
                            }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabException e)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(e));
                        Log.get().warn(
                            "This is an application error, if it is not permission related.", e);
                    }
                  
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
            {
                L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
                scarabR.setAlertMessage(l10nMessage);
                Log.get().warn("Exception during issue copy/move", e);
                return;
            }
                  
// in java/org/tigris/scarab/reports/ReportHeading.java
catch (Exception e)
                {
                    Log.get().warn("Error on attribute id", e);
                    result = false;
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
            {
                LOG.warn("Could not assign nullAttribute", e);
            }
                  
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + className + '\'', e);
            }
                  
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + linkClass.getName() + 
                               "'; will use default link tool.", e);
                result = new ErrorEmailLink(module);            
            }
                  
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
                  
// in java/org/tigris/scarab/util/Email.java
catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
69
getMessage 42 
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            valid = false;
            dateField.setMessage("format error ["+e.getMessage()+"]");
        }
                  
// in java/org/tigris/scarab/search/CachedQuery.java
catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                final L10NKey msg = new L10NKey("ErrorPossibleMemoryLeak");
                Log.get().warn(msg.getMessage(), e);
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            // I think it might be ok to return null from this method
            // but until that is investigated return the default in
            // event of error
            result = ScarabConstants.DEFAULT_LOCALE;
            Log.get().warn(
                "AbstractScarabUser.getLocale() could not "
                    + "retrieve locale for user id="
                    + getUserId()
                    + "; Error message: "
                    + e.getMessage());
        }
                  
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
                  
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                    {
                        log.error("queueNotifications(): while processing activity queue: " + e.getMessage(),e);
                        logNotificationData(notification);
                        log.error("queueNotifications(): Abort this run");
                        break;
                    }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
        {
            log.error("queueNotifications(): while setting up the activity queue: " + e.getMessage(),e);
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(Exception e)
        {
            log.error("queueNotifications(): while dumping notificationData: " + e.getMessage(),e);
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
        {
            Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
            Log.get().warn("db layer reported: ["+e.getMessage()+"]");
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
            {
                Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                Log.get().warn("db layer reported: ["+e.getMessage()+"]");
            }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
                {
                    Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                    Log.get().warn("db layer reported: ["+e.getMessage()+"]");
                }
                  
// in java/org/tigris/scarab/screens/admin/ViewXMLExportIssues.java
catch (Exception e)
                {
                    data.setTarget("admin,XMLExportIssues.vm");
                    scarabR.setAlertMessage(l10n.getMessage(e));
                    return;
                }
                  
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
catch (Exception e)
                {
                    resultCode = RESULT_ERROR_EXCEPTION;
                    // TODO: Improve localizability of this text.
                    resultString = l10n.get("ProcessingErrors") + ": "
                        + e.getMessage();
                }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/actions/TemplateList.java
catch (Exception e)
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.getMessage(e));
                }
                  
// in java/org/tigris/scarab/actions/ModifyModule.java
catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
                  
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception se)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        return;
                    }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                            {
                                log().error("Error adding attribute option:", e);
                                scarabR.setAlertMessage("Error adding attribute option:" + l10n.getMessage(e));
                            }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabLocalizedTorqueException slte) 
                        {
                            String msg = slte.getMessage(l10n);
                            scarabR.setAlertMessage(msg);
                        }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (TorqueException te) 
                        {
                            String msg = te.getMessage();
                            scarabR.setAlertMessage(msg);
                        }
                  
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabException e)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(e));
                        Log.get().warn(
                            "This is an application error, if it is not permission related.", e);
                    }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception se)
        {
            scarabR.setAlertMessage(l10n.getMessage(se));
        }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch(Exception e)
            {
                String l10nMessage = l10n.getMessage(e);
                scarabR.setAlertMessage(l10nMessage);
                return;
            }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    scarabR.setAlertMessage(l10n.getMessage(se));
                }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
            {
                childId.setMessage(se.getL10nMessage().getMessage(l10n));
                return false;
            }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    // it will error out if they attempt to delete
                    // a dep via a child dep.
                    String l10nKey = se.getMessage();
                    scarabR.setAlertMessage(l10n.get(l10nKey));
                }
                  
// in java/org/tigris/scarab/actions/ChangePassword.java
catch (PasswordMismatchException pme)
                {
                    scarabR.setAlertMessage(l10n.getMessage(pme));
                    setTarget(data, template);
                }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (UnknownEntityException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().info("Invalid login attempted: " + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (PasswordMismatchException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().debug("Password mis-match during login attempt: "
                           + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch(Exception ex)
        {
            log.error("Double error: Can not dump Email context. ("+ex.getMessage()+")");
            log.error("key["+keystring+"]");
            log.error("val["+val+"]");
        }
                  
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (MissingResourceException e)
                            {
                                Log.get().debug("Missing database initialization "
                                                + "resource: " + e.getMessage());
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }
                  
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
                  
// in java/org/tigris/scarab/util/Email.java
catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
100
printStackTrace
 42 
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw e;
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
		{
		e.printStackTrace(); throw e; //EXCEPTION
		}
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
        e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
            {
                e.printStackTrace();
                moduleCodeLength = 4;
            }
                  
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
catch (IOException e) {
	    	e.printStackTrace();
	    }
                  
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
			
		}
                  
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
		}
                  
// in java/org/tigris/scarab/attribute/OptionAttribute.java
catch (TorqueException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
            {
                e.printStackTrace();
            }
                  
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/om/TransitionManager.java
catch (TorqueException te)
            {
                te.printStackTrace();
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
            {
                e.printStackTrace();
                getLog().error(e);
                return null;
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e) {
			e.printStackTrace();
			return false;
		}
                  
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            getLog().error(e);
                            e.printStackTrace();
                        }
                  
// in java/org/tigris/scarab/om/ActivitySet.java
catch (NoSuchElementException nsee)
                        {
                            Throwable th = new Throwable("No such element exception occured.(ignore and assume transitionToSealed=false)");
                            th.printStackTrace();
                            result = false;
                        }
                  
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (Exception e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
                  
// in java/org/tigris/scarab/om/AttributeOption.java
catch (Exception e)
        {
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
catch(Exception e)
                {
                    e.printStackTrace();
                }
                  
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
catch(Exception e)
                {
                    e.printStackTrace();
                }
                  
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException ex) 
                {
                    ex.printStackTrace();
                    importErrors.add(ex);
                }
42
getLog 33 
                  
// in java/org/tigris/scarab/om/Activity.java
catch (Exception e)
            {
                getLog().error("Activity.getAttachment(): ", e);
            }
                  
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
            {
                getLog().error(e);
                dispVal = "!Error-Check Logs!";
            }
                  
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
                  
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
            {
                getLog().error(e);
                dispVal = "!Error-Check Logs!";
            }
                  
// in java/org/tigris/scarab/om/Condition.java
catch (Exception e) {
            this.getLog().debug("evaluate: Failed to evaluate, will return false. ", e);
        }
                  
// in java/org/tigris/scarab/om/Condition.java
catch (Exception e) {
            this.getLog().debug("evaluate: Failed to evaluate, will return empty String. ", e);
        }
                  
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
catch (TorqueException e)
        {
            getLog().error("getName(): " + e);
        }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                getLog().error("Error getting HTTP_DOMAIN:", e);
            }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                getLog().error("Error getting DOMAIN_NAME:", e);
            }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
        {
            getLog().error("isIssueReasonRequired(): " + te);
        }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
                getLog().error("isIssueReasonVisible(): " + te);
            }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
        {
            getLog().error("isIssueReasonRequiredInherited(): " + te);
        }
                  
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            getLog().error("getCommentRenderingEngine(): " + e);
        }
                  
// in java/org/tigris/scarab/om/NotificationStatus.java
catch (TorqueException te)
        {
            getLog().error("setActivity(): Cannot find activity's issue!: " + te);
        }
                  
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
            {
                e.printStackTrace();
                getLog().error(e);
                return null;
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException e)
        {
            getLog().error("Could not compile regex: " + regex, e);
            try
            {
                rep = rec.compile(REGEX_PREFIX + REGEX_SUFFIX);
            }
            catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
        }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
                  
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            getLog().error("Problem determining whether issue is template");
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            getLog().error(e);
                            e.printStackTrace();
                        }
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e)
            {
                getLog().error("An exception prevented retrieving any modules", e);
            }
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception te)
        {
            getLog().error("getAssignIssuesList(): " + te);
        }
                  
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
            {
                getLog().error("Error getting the issue type name: ", e);
            }
                  
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
            {
                getLog().error("Error getting the issue type description: ", e);
            }
                  
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
45
add 32 
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
        {
            // return the text as is and log the error
            result = new ArrayList(1);
            result.add(text);
            Log.get().warn("Could not linkify text: " + text, e);
        }
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e) 
                {
                    uniqueComments.add(notificationStatus);
                }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("addAttributeOption(String, String) -  : attr=" + attr 
                    + ", opt=" + opt + ", rslt=" + rslt, e);

            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", options=" + options + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotLocateUsername", userStr);
                    importErrors.add(error);
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "CouldNotFindGlobalAttribute", activityAttribute);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption",
                                     activity.getOldOption());
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException ex) 
                {
                    ex.printStackTrace();
                    importErrors.add(ex);
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }
909
L10NMessage 23 
                  
// in java/org/tigris/scarab/om/Issue.java
catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
                  
// in java/org/tigris/scarab/actions/Search.java
catch(Exception e)
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneral,e);
                    scarabR.setAlertMessage(msg);
                }
                  
// in java/org/tigris/scarab/actions/ForgotPassword.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
                  
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }
                  
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
catch(Exception e)
                        {
                            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.CouldNotSendNotification,e);
                            scarabR.setAlertMessage(l10nMessage);
                        }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (Exception e)
                    {
                        L10NMessage l10nMessage =new L10NMessage(EMAIL_ERROR,e);
                        scarabR.setAlertMessage(l10nMessage);
                    }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch(Exception e)
                            {
                                Localizable msg = new L10NMessage(L10NKeySet.ExceptionEmailFailure,e);
                                scarabR.setAlertMessage(msg);
                            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
                  
// in java/org/tigris/scarab/actions/AssignIssue.java
catch(Exception e)
                {
                    L10NMessage l10nMessage = new L10NMessage(EMAIL_ERROR,e);
                    scarabR.setAlertMessage(l10nMessage);
                }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionTurbineGeneric,e);
            setAlertMessage(scarabR,msg);
            failAction(data, "Login.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
            {
                L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
                scarabR.setAlertMessage(l10nMessage);
                Log.get().warn("Exception during issue copy/move", e);
                return;
            }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
                  
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
                  
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
86
debug 22 
                  
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
catch (Exception e)
                {
                    LOG.debug("Could not set high buffer size so client may " +
                              "affect timing results.");
                }
                  
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().debug("Error: ", e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabUserTool.java
catch (Exception e)
        {
            // Logged at debug level, as a null user is interpreted
            // as an invalid user name
            Log.get().debug("User, "+username+" could not be found,", e);
        }
                  
// in java/org/tigris/scarab/om/Condition.java
catch (Exception e) {
            this.getLog().debug("evaluate: Failed to evaluate, will return false. ", e);
        }
                  
// in java/org/tigris/scarab/om/Condition.java
catch (Exception e) {
            this.getLog().debug("evaluate: Failed to evaluate, will return empty String. ", e);
        }
                  
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
                  
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
                  
// in java/org/tigris/scarab/screens/ViewAttachment.java
catch (java.io.IOException ioe)
                    {
                        Log.get().debug("File download was aborted: " + 
                                        attachment.getFullPath());
                        break;
                    }
                  
// in java/org/tigris/scarab/screens/SaveTemplate.java
catch (Exception e)
        {
            title = l10n.get("SaveTemplate");
            Log.get().debug("no current issue type, cannot retrieve SaveTemplate title", e);
        }
                  
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
                {
                    // would probably be a hack of the form
                    scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                    Log.get().debug("", e);
                    return;
                }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
            {
                log().debug("Delete error: ", e);
                return false;
            }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    log().debug("Delete error: ", e);
                }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (PasswordMismatchException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().debug("Password mis-match during login attempt: "
                           + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (MissingResourceException e)
                            {
                                Log.get().debug("Missing database initialization "
                                                + "resource: " + e.getMessage());
                            }
                  
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not parse port number", e);
        }
                  
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not get scheme parameter", e);
        }
                  
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not get script name parameter", e);
        }
                  
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
        {
            log.debug("", e);
            // use the basic email
        }
                  
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
            {
                Log.get().debug(e);
            }
                  
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
        {
            Log.get().debug(e);
        }
                  
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
        {
            Log.get().debug(e);
        }
171
println 18 
                  
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
catch (IOException e) {
	    	System.out.println("There is probably no build.properties file.");
	    }
                  
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		}
                  
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
			
		}
                  
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		}
                  
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
		}
                  
// in java/org/tigris/scarab/xmlrpc/SimpleHandlerClient.java
catch (Exception e)
        {
            System.err.println("Error invoking service: " + e);
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandlerClient.java
catch (Exception e)
        {
            System.err.println("Error invoking service: " + e);
        }
                  
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
                  
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
                  
// in java/org/tigris/scarab/util/TurbineInitialization.java
catch (Exception e)
        {
            System.err.println("Can't read the properties file (" + 
                configDir + configFile + "). ");
        }
70
getName 14 
                  
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
catch (Exception e)
            {
                LOG.warn(
                    "Could not set locale info for user ["
                        + user.getName()
                        + "]");
            }
                  
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
        {
            Log.get().warn("Could not get RIA records for " + getName(), e);
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
                  
// in java/org/tigris/scarab/notification/NotificationManagerFactory.java
catch (Exception e)
            {
                log
                        .error("Could not instantiate notification manager '"
                                + classname + "'. Defaulting to '"
                                + ScarabNotificationManager.class.getName()
                                + "': " + e);
                instance = new ScarabNotificationManager();
            }
                  
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
        {
            Log.get(this.getClass().getName())
                    .error("canMakeTransition: " + te);
        }
                  
// in java/org/tigris/scarab/util/ComponentLocator.java
catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + linkClass.getName() + 
                               "'; will use default link tool.", e);
                result = new ErrorEmailLink(module);            
            }
283
format 13 
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
                  
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("RoleExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
                  
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotLocateUsername", userStr);
                    importErrors.add(error);
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "CouldNotFindGlobalAttribute", activityAttribute);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption",
                                     activity.getOldOption());
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
91
getLocale 10 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotLocateUsername", userStr);
                    importErrors.add(error);
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "CouldNotFindGlobalAttribute", activityAttribute);
            importErrors.add(error);
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption",
                                     activity.getOldOption());
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
66
setTarget 10 
                  
// in java/org/tigris/scarab/screens/admin/ViewXMLExportIssues.java
catch (Exception e)
                {
                    data.setTarget("admin,XMLExportIssues.vm");
                    scarabR.setAlertMessage(l10n.getMessage(e));
                    return;
                }
                  
// in java/org/tigris/scarab/actions/ForgotPassword.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
                  
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (IncompatibleMITListException e)
        {
            scarabR.setAlertMessage(L10NKeySet.IncompatibleMITListReport);
            setTarget(data, "reports,XModuleList.vm");
        }
                  
// in java/org/tigris/scarab/actions/ModifyModule.java
catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
                  
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
                  
// in java/org/tigris/scarab/actions/ChangePassword.java
catch (PasswordMismatchException pme)
                {
                    scarabR.setAlertMessage(l10n.getMessage(pme));
                    setTarget(data, template);
                }
182
toString 8 
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch( ConversionException ce)
        {
            // This happens, if the Turbine Property contains data, which can
            // not be converted to a String. This has been seen on JBOSS.
            // Note: getProperty() does not resolve ${} values, so it is not an
            // option to use it instead of getString(). But in the case of
            // non convertible objects, getProperty().toString() is the best bet.
            // In my opinion this should be handled inside of Configuration, 
            // or at least we should be given a test method Configuration.isString(key)
            // So we could avoid this stuff here...
            // just my 2 cents. (hussayn dabbous)
            result = getTurbineConfiguration().getProperty(key).toString();
        }
                  
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            return super.toString();
        }
                  
// in java/org/tigris/scarab/om/ROptionOption.java
catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            s = "ERROR! on " + super.toString();
            Log.get().error("", e);
        }
                  
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (IOException e) {
			throw new LoginException(e.toString());
		}
                  
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}
                  
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
274
getParameters 7 
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
                  
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
365
setString 7 
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
                  
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
                  
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
71
info 6 
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
            {
                Log.get().info("[ScarabRequestTool] Unable to retrieve Module: " +
                         key, e);
            }
                  
// in java/org/tigris/scarab/screens/Default.java
catch (Exception e)
            {
                Log.get().info(
                    "Error getting page title for Screen: " + data.getTarget());
            }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    // we do not want any exception thrown here to affect
                    // the user experience, it is just considered a 
                    // non-detectable file type.  But still the exception is
                    // not expected, so log it.
                    mimeAField.setMessage("intake_CouldNotDetermineMimeType");
                    Log.get().info(
                        "Could not determine mimetype of uploaded file.", e);
                }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (UnknownEntityException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().info("Invalid login attempted: " + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (LoginException e) {
            cbh.clearPassword();
            log.info(e);

            return null;
        }
                  
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            allowed = false;
            Log.get().info("Could not check permission due to: ", e);
        }
45
getInstance 5 
                  
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
                  
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
478
getScarabRequestTool 5 
                  
// in java/org/tigris/scarab/actions/ForgotPassword.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/QueryList.java
catch (Exception e)
               {
                   ScarabLocalizationTool l10n = getLocalizationTool(context);
                   getScarabRequestTool(context).setAlertMessage(NO_PERMISSION_MESSAGE);
               }
                  
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("RoleExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
                  
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
                  
// in java/org/tigris/scarab/actions/AssignIssue.java
catch (NumberFormatException nfe) // new Integer(issueId) above could fail
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.BadIntegerConversion);
        }
169
L10NKey 4 
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                final L10NKey msg = new L10NKey("ErrorPossibleMemoryLeak");
                Log.get().warn(msg.getMessage(), e);
            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
434
failAction 4 
                  
// in java/org/tigris/scarab/actions/Login.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionTurbineGeneric,e);
            setAlertMessage(scarabR,msg);
            failAction(data, "Login.vm");
            return false;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (UnknownEntityException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().info("Invalid login attempted: " + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (PasswordMismatchException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().debug("Password mis-match during login attempt: "
                           + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
                  
// in java/org/tigris/scarab/actions/Login.java
catch (DataBackendException e)
        {
            setAlertMessage(scarabR, L10NKeySet.ExceptionDatabaseGenericError);
            Log.get().error("Error while attempting to log in", e);
            failAction(data, "Login.vm");
            return null;
        }
6
getResponse 4 
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
28
renderingError
 4 
                  
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
            {
                renderingError(filename, e);
            }
                  
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            renderingError(filename, e);
        }
                  
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            renderingError(filename, e);
        }
                  
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
            {
                renderingError(filename, e);
            }
4
sendError 4 
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
                  
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
5
setMessage 4 
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            valid = false;
            dateField.setMessage("format error ["+e.getMessage()+"]");
        }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    // we do not want any exception thrown here to affect
                    // the user experience, it is just considered a 
                    // non-detectable file type.  But still the exception is
                    // not expected, so log it.
                    mimeAField.setMessage("intake_CouldNotDetermineMimeType");
                    Log.get().info(
                        "Could not determine mimetype of uploaded file.", e);
                }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
        {
            type.setMessage(l10n.get(L10NKeySet.SelectRelation));
            return false;
        }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
            {
                childId.setMessage(se.getL10nMessage().getMessage(l10n));
                return false;
            }
32
Boolean 3 
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("addAttributeOption(String, String) -  : attr=" + attr 
                    + ", opt=" + opt + ", rslt=" + rslt, e);

            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", options=" + options + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
14
createBadResourceValue
 3 
                  
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch(Exception e)
        {
            value = createBadResourceValue(key, e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch(Exception e)
        {
            value = createBadResourceValue(key, e);
        }
                  
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (Exception e)
        {
            value = createBadResourceValue(key, e);
        }
3
dumpContextToLog
 3 
                  
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }
                  
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }
                  
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
3
getCause
 3 
                  
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
3
getClass 3 
                  
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
                  
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
                  
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
        {
            Log.get(this.getClass().getName())
                    .error("canMakeTransition: " + te);
        }
17
getNewOption 3 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
7
getUserName 3 
                  
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
                  
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
            {
                log.error(
                        "Couldn't determine locale for user " + user
                                .getUserName(), e);
            }
37
remove 3 
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                        {
                            scarabR.setAlertMessage(
                               l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
                  
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }
137
compile 2 
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException e)
        {
            getLog().error("Could not compile regex: " + regex, e);
            try
            {
                rep = rec.compile(REGEX_PREFIX + REGEX_SUFFIX);
            }
            catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
        }
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
8
getACL 2 
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (DataBackendException e)
                                {
                                    // maybe the role request was approved 
                                    // by another admin?
                                    AccessControlList acl = su.getACL();
                                    if (acl.hasRole( role, (Group) module ) )
                                    {
                                        hasRoles = true;
                                    }
                                    else
                                    {
                                        // Something went wrong, ignore for now.
                                    }
                                }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
12
getDomain 2 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
12
getId 2 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
23
getIdTableKey 2 
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
6
getL10nMessage
 2 
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (ScarabException e)
        {
            setAlertMessage(e.getL10nMessage());
        }
                  
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
            {
                childId.setMessage(se.getL10nMessage().getMessage(l10n));
                return false;
            }
2
getOldOption 2 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption",
                                     activity.getOldOption());
                                importErrors.add(error);
                            }
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
4
getOptionId 2 
                  
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
                  
// in java/org/tigris/scarab/om/TransitionPeer.java
catch (TorqueException e) {
			log.error("getTransitions(): AttributeOption: " + fromOption.getOptionId() + ": " + e);
		}
129
getString 2 
                  
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
                  
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
304
getUserId 2 
                  
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            // I think it might be ok to return null from this method
            // but until that is investigated return the default in
            // event of error
            result = ScarabConstants.DEFAULT_LOCALE;
            Log.get().warn(
                "AbstractScarabUser.getLocale() could not "
                    + "retrieve locale for user id="
                    + getUserId()
                    + "; Error message: "
                    + e.getMessage());
        }
                  
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            result = "Error on Option Id=" + rua.getUserId();
            Log.get().error(result, e);
        }
143
hasRole 2 
                  
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (DataBackendException e)
                                {
                                    // maybe the role request was approved 
                                    // by another admin?
                                    AccessControlList acl = su.getACL();
                                    if (acl.hasRole( role, (Group) module ) )
                                    {
                                        hasRoles = true;
                                    }
                                    else
                                    {
                                        // Something went wrong, ignore for now.
                                    }
                                }
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
7
save 2 
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }
                  
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
236
saveIdTableKey
 2 
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }
2
setConfirmMessage 2 
                  
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("RoleExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
                  
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
123
setHeader 2 
                  
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (SmbAuthException sae)
            {
                response.setHeader("WWW-Authenticate", "NTLM");
                response.setHeader("Connection", "close");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.flushBuffer();
                return;
            }
6
ArrayList 1 
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
        {
            // return the text as is and log the error
            result = new ArrayList(1);
            result.add(text);
            Log.get().warn("Could not linkify text: " + text, e);
        }
226
ErrorEmailLink
 1 
                  
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + linkClass.getName() + 
                               "'; will use default link tool.", e);
                result = new ErrorEmailLink(module);            
            }
1
IssueType 1 
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
                {
                    issueType = new IssueType(defaultIssueTypeId);
                }
10
PorterStemAnalyzer
 1 
                  
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch( Exception e)
        {
            analyzer = new PorterStemAnalyzer();
            Log.get().error("Could not create Lucene Analyzer (" + analyzerClassName + "), using default.", e);
        }
1
ScarabNotificationManager
 1 
                  
// in java/org/tigris/scarab/notification/NotificationManagerFactory.java
catch (Exception e)
            {
                log
                        .error("Could not instantiate notification manager '"
                                + classname + "'. Defaulting to '"
                                + ScarabNotificationManager.class.getName()
                                + "': " + e);
                instance = new ScarabNotificationManager();
            }
1
ScarabPaginatedList 1 
                  
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Problem getting user list", e);
            list = new ScarabPaginatedList();
        }
5
String 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }
39
Throwable 1 
                  
// in java/org/tigris/scarab/om/ActivitySet.java
catch (NoSuchElementException nsee)
                        {
                            Throwable th = new Throwable("No such element exception occured.(ignore and assume transitionToSealed=false)");
                            th.printStackTrace();
                            result = false;
                        }
2
append 1 
                  
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
        {
            sb.append("Error retrieving list items. see logs.");
            Log.get().warn("", e);
        }
207
clear 1 
                  
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
81
clearPassword 1 
                  
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (LoginException e) {
            cbh.clearPassword();
            log.info(e);

            return null;
        }
3
createAttachment 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
4
flushBuffer 1 
                  
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (SmbAuthException sae)
            {
                response.setHeader("WWW-Authenticate", "NTLM");
                response.setHeader("Connection", "close");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.flushBuffer();
                return;
            }
2
getArtifactType 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
5
getCode 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
82
getColumnNumber 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }
4
getErrorOffset
 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
1
getFormat 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
7
getFullPath 1 
                  
// in java/org/tigris/scarab/screens/ViewAttachment.java
catch (java.io.IOException ioe)
                    {
                        Log.get().debug("File download was aborted: " + 
                                        attachment.getFullPath());
                        break;
                    }
11
getIdAsInt 1 
                  
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
4
getIdCount 1 
                  
// in java/org/tigris/scarab/util/Email.java
catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
10
getInfoMessage 1 
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
2
getInternalAttribute 1 
                  
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
catch (NumberFormatException nfe)
                    {
                        pref.setInternalAttribute(ids[i]);
                        orderMap.put(pref.getInternalAttribute(), order);
                    }
7
getLineNumber 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }
4
getLocalizationTool 1 
                  
// in java/org/tigris/scarab/actions/QueryList.java
catch (Exception e)
               {
                   ScarabLocalizationTool l10n = getLocalizationTool(context);
                   getScarabRequestTool(context).setAlertMessage(NO_PERMISSION_MESSAGE);
               }
110
getMethodResult 1 
                  
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
136
getModuleCode 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
3
getParentId 1 
                  
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
17
getProperty 1 
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch( ConversionException ce)
        {
            // This happens, if the Turbine Property contains data, which can
            // not be converted to a String. This has been seen on JBOSS.
            // Note: getProperty() does not resolve ${} values, so it is not an
            // option to use it instead of getString(). But in the case of
            // non convertible objects, getProperty().toString() is the best bet.
            // In my opinion this should be handled inside of Configuration, 
            // or at least we should be given a test method Configuration.isString(key)
            // So we could avoid this stuff here...
            // just my 2 cents. (hussayn dabbous)
            result = getTurbineConfiguration().getProperty(key).toString();
        }
11
getRealName 1 
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
18
getReportId 1 
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }
2
getRootCause
 1 
                  
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
1
getTarget 1 
                  
// in java/org/tigris/scarab/screens/Default.java
catch (Exception e)
            {
                Log.get().info(
                    "Error getting page title for Screen: " + data.getTarget());
            }
15
getTimestamp 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
3
getTurbineConfiguration 1 
                  
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch( ConversionException ce)
        {
            // This happens, if the Turbine Property contains data, which can
            // not be converted to a String. This has been seen on JBOSS.
            // Note: getProperty() does not resolve ${} values, so it is not an
            // option to use it instead of getString(). But in the case of
            // non convertible objects, getProperty().toString() is the best bet.
            // In my opinion this should be handled inside of Configuration, 
            // or at least we should be given a test method Configuration.isString(key)
            // So we could avoid this stuff here...
            // just my 2 cents. (hussayn dabbous)
            result = getTurbineConfiguration().getProperty(key).toString();
        }
2
getType 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }
27
hasModuleCode 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
6
isConfirmed 1 
                  
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
6
isEnabledFor
 1 
                  
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TorqueException e) {
                    if (log.isEnabledFor(org.apache.log4j.Priority.WARN)) {
                        log
                                .warn(
                                        "mapAttributeOptionToAllModuleIssueTypes(String, String) - IssueTypeMApping alreadyt exists for this combination : attribute=" + attribute + ", option=" + option + ", it=" + it, null); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                    }
                }
1
length 1 
                  
// in java/org/tigris/scarab/util/Email.java
catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
204
logNotificationData
 1 
                  
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                    {
                        log.error("queueNotifications(): while processing activity queue: " + e.getMessage(),e);
                        logNotificationData(notification);
                        log.error("queueNotifications(): Abort this run");
                        break;
                    }
1
print 1 
                  
// in java/org/tigris/scarab/screens/ReportExport.java
catch (Exception e)
        {
            printer.print(l10n.get("ErrorOccurredCheckingMessage"));
        }
26
put 1 
                  
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
catch (NumberFormatException nfe)
                    {
                        pref.setInternalAttribute(ids[i]);
                        orderMap.put(pref.getInternalAttribute(), order);
                    }
326
reactivateUserIfDeleted 1 
                  
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
2
setDeleted 1 
                  
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }
28
setInfoMessage 1 
                  
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
35
setInternalAttribute 1 
                  
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
catch (NumberFormatException nfe)
                    {
                        pref.setInternalAttribute(ids[i]);
                        orderMap.put(pref.getInternalAttribute(), order);
                    }
2
setNew 1 
                  
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
catch (Exception e)
        {
            rule.setNew(true);
        }
5
setOption1Id 1 
                  
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
3
setOption2Id 1 
                  
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
3
setStatus 1 
                  
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (SmbAuthException sae)
            {
                response.setHeader("WWW-Authenticate", "NTLM");
                response.setHeader("Connection", "close");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.flushBuffer();
                return;
            }
7
Method Nbr Nbr total
close 9 
                  
// in java/org/tigris/scarab/om/Attachment.java
finally
        {
            try
            {
                in.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            try
            {
                out.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
        }
                  
// in java/org/tigris/scarab/screens/ViewAttachment.java
finally
            {
                if (bis != null)
                {
                    bis.close();
                }
            }
                  
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
finally
            {
                try
                {
                    if (writer != null)
                    {
                        writer.close();
                    }
                }
                catch (IOException ignored)
                {
                }
            }
                  
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
finally
        {
            try
            {
                if (bytes != null)
                {
                    bytes.close();
                }
            }
            catch (IOException ignored)
            {
            }
        }
                  
// in java/org/tigris/scarab/services/DatabaseInitializer.java
finally
        {
            if (con != null) 
            {
                con.close();
            }
        }
                  
// in java/org/tigris/scarab/util/AntServlet.java
finally
            {
                if (in != null)
                {
                    in.close();
                }
            }
                  
// in java/org/tigris/scarab/util/AntServlet.java
finally
        {
            if (out != null)
            {
                out.close();
            }
        }
                  
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
finally
        {
            is.close();
        }
23
debug 2 
                  
// in java/org/tigris/scarab/om/Attachment.java
finally
        {
            try
            {
                in.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            try
            {
                out.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
        }
171
get 2 
                  
// in java/org/tigris/scarab/om/Attachment.java
finally
        {
            try
            {
                in.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            try
            {
                out.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
        }
1227
getMessage 2 
                  
// in java/org/tigris/scarab/om/Attachment.java
finally
        {
            try
            {
                in.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            try
            {
                out.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
        }
100
unlockExclusive
 2 
                  
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
finally
        {
            unlockExclusive();
        }
                  
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
finally
        {
            unlockExclusive();
        }
2
fireBuildFinished
 1 
                  
// in java/org/tigris/scarab/actions/setup/AntRunner.java
finally
        {
            project.fireBuildFinished(error);
        }
1
flush 1 
                  
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
finally
        {
            try
            {
                if (writer != null)
                {
                    writer.flush();
                }
            }
            catch (Exception ignored)
            {
            }
        }
10
releaseInstance
 1 
                  
// in java/org/tigris/scarab/util/word/IssueSearch.java
finally
            {
                SearchFactory.releaseInstance(LuceneSearchIndex);
            }
1
setErr 1 
                  
// in java/org/tigris/scarab/actions/setup/AntRunner.java
finally
            {
                // put back the original security manager
                // actually, did it ever change ???
                // Need to look into the ant sources to answer this
                // question [HD]
                if (oldsm != null)
                {
                    System.setSecurityManager(oldsm);
                }

                System.setOut(out);
                System.setErr(err);
            }
2
setFilterEnabled 1 
                  
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
finally
            {
                l10n.setFilterEnabled(pushFilterEnable);
            }
3
setForceUseDefault 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
finally
        {
            // Re-enable workflow.
            WorkflowFactory.setForceUseDefault(false);
        }
2
setOut 1 
                  
// in java/org/tigris/scarab/actions/setup/AntRunner.java
finally
            {
                // put back the original security manager
                // actually, did it ever change ???
                // Need to look into the ant sources to answer this
                // question [HD]
                if (oldsm != null)
                {
                    System.setSecurityManager(oldsm);
                }

                System.setOut(out);
                System.setErr(err);
            }
2
setParseContext 1 
                  
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
finally
        {
            importErrors.setParseContext(null);
        }
2
setSecurityManager
 1 
                  
// in java/org/tigris/scarab/actions/setup/AntRunner.java
finally
            {
                // put back the original security manager
                // actually, did it ever change ???
                // Need to look into the ant sources to answer this
                // question [HD]
                if (oldsm != null)
                {
                    System.setSecurityManager(oldsm);
                }

                System.setOut(out);
                System.setErr(err);
            }
1

Reference Table

This table concatenates the results of the previous tables.

Checked/Runtime Type Exception Thrown Thrown from Catch Declared Caught directly Caught
with Thrown 		Caught
with Thrown Runtime
unknown (Lib) AddressException 0 0 0 1 
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch( AddressException e)
        {
            return false;
        }
0 0
unknown (Lib) ArrayIndexOutOfBoundsException 2 
            
// in java/org/tigris/scarab/util/WindowIterator.java
public Object get(int i)
    {
        if (i < 0 && (-1 * i) > bsize) 
        {
            throw new ArrayIndexOutOfBoundsException("window was only defined "
                + bsize + " in the negative direction. Argument was " + i); //EXCEPTION
        }

        if (i > 0 && i > fsize) 
        {
            throw new ArrayIndexOutOfBoundsException("window was only defined "
                + fsize + " in the positive direction. Argument was " + i); //EXCEPTION
        }
        
        return window[bsize + i];
    }
0 0 1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
0
unknown (Lib) BuildException 1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
public void execute() 
        throws BuildException
    {
        try
        {
            importIssues.execute();
        }
        catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
    }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
public void execute() 
        throws BuildException
    {
        try
        {
            importIssues.execute();
        }
        catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
    }
0 0 0
unknown (Lib) ClassCastException 1 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public int compareTo(Object obj)
    {
        //TODO [HD] what about using instanceof, or
        //          probably better delete the whole
        //          if-block (see note n ScarabModule.compereTo()
        if (this.getClass() != obj.getClass())
        {
            throw new ClassCastException(); //EXCEPTION 
        }
        String name1 = ((Group)obj).getName();
        String name2 = this.getName();

        return name2.compareTo(name1);
    }
0 0 1 
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
1 
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
1
unknown (Lib) ClassNotFoundException 0 0 1 
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
private void readObject(java.io.ObjectInputStream in)
         throws java.io.IOException, ClassNotFoundException
    {
        try
        {
            in.defaultReadObject();
        }
        catch (java.io.NotActiveException e)
        {
        }
        initThreadLocals();
    }
1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
0
unknown (Lib) ConversionException 0 0 0 2 
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch( ConversionException ce)
        {
            // This happens, if the Turbine Property contains data, which can
            // not be converted to a String. This has been seen on JBOSS.
            // Note: getProperty() does not resolve ${} values, so it is not an
            // option to use it instead of getString(). But in the case of
            // non convertible objects, getProperty().toString() is the best bet.
            // In my opinion this should be handled inside of Configuration, 
            // or at least we should be given a test method Configuration.isString(key)
            // So we could avoid this stuff here...
            // just my 2 cents. (hussayn dabbous)
            result = getTurbineConfiguration().getProperty(key).toString();
        }
            
// in java/org/tigris/scarab/actions/admin/AppConfigurationSettings.java
catch( ConversionException ce)
            {
            	// This happens, if the Turbine Property is not a String.
            	// This has been seen on JBOSS. Since we can't provide any
            	// reasonable value here, ignore the entry and continue.
            	log.warn("Turbine property ["+realKey+"] is not a String value. No update done. (continue)");
            	turbineValue = null;
            }
0 0
unknown (Lib) DataBackendException 6 
            
// in java/org/tigris/scarab/om/ScarabModulePeer.java
public static boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        Criteria criteria = new Criteria();
        criteria.addSelectColumn(MODULE_ID);
        String name = ((Module)group).getRealName();
        criteria.add(MODULE_NAME, name);
        criteria.add(PARENT_ID, ((Module)group).getParentId());
        List results = BasePeer.doSelect(criteria);
        if(results.size() > 1)
        {
            throw new DataBackendException("Multiple groups named '" +
                name + "' exist!"); //EXCEPTION
        }
        return (results.size()==1);
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public GroupSet getGroups(Criteria criteria)
        throws DataBackendException
    {
        List groups = null;
        try
        {
            groups = ScarabModulePeer.doSelect(criteria);
        }
        catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
        if (groups == null)
        {
            groups = new ArrayList(0);
        }
        return new GroupSet(groups);
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public void saveGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            if (!((Persistent)group).isNew()) 
            {
                group.save();
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized Group addGroup(Group group) 
        throws DataBackendException, EntityExistsException
    {
        try
        {
            lockExclusive();
            if (((Persistent)group).isNew()) 
            {
                group.save();
                // add the group to system-wide cache
                getAllGroups().add(group);
                return group;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        // the only way we could get here without return/throw tirggered
        // is that the groupExists was true.
        throw new EntityExistsException("Group '" + group + 
            "' already exists"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void removeGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            lockExclusive();
            if (!((Persistent)group).isNew()) 
            {
                ((Module)group).setDeleted(true);
                group.save();
                getAllGroups().remove(group);
            }
        }
        catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void renameGroup(Group group, String name)
        throws DataBackendException, UnknownEntityException
    {
        throw new DataBackendException("rename is not supported"); //EXCEPTION

        /* this stuff is cut-n-paste
        boolean groupExists = false;
        try
        {
            lockExclusive();
            groupExists = checkExists(group);
            if(groupExists)
            {
                ((SecurityObject)group).setName(name);
                Criteria criteria = GroupPeer.buildCriteria(group);
                GroupPeer.doUpdate(criteria);
                return;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("renameGroup(Group,String)" ,e);
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'");
        */
    }
4 
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
9 
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void createNewUser()
        throws TorqueException, DataBackendException, EntityExistsException
    {
        // get a unique id for validating the user
        final String uniqueId = RandomStringUtils
                .randomAlphanumeric(UNIQUE_ID_MAX_LEN);
        // add it to the perm table
        setConfirmed(uniqueId);
        TurbineSecurity.addUser (this, getPassword());
        setPasswordExpire();
        
        // add any roles the anonymous user has, if she is enabled.
        if(ScarabUserManager.anonymousAccessAllowed())
        {
            final ScarabUserImpl anonymous = (ScarabUserImpl) ScarabUserManager.getAnonymousUser();
            final List/*<ScarabModule>*/ modules = anonymous.getNonGlobalModules();
            for(Iterator it0 = modules.iterator(); it0.hasNext(); )
            {
                final ScarabModule module = (ScarabModule)it0.next();
                final List/*<Roles>*/ roles = anonymous.getRoles(module);
                for(Iterator it1 = roles.iterator(); it1.hasNext(); )
                {
                    try 
                    {
                        final Role role = (Role) it1.next();
                        TurbineSecurity.grant(this, (Group) module, role);

                        // TODO: Needs to be refactored into the Users system?
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.GET_ACL);
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable) role, module);
                        
                    }catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/ScarabModulePeer.java
public static boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        Criteria criteria = new Criteria();
        criteria.addSelectColumn(MODULE_ID);
        String name = ((Module)group).getRealName();
        criteria.add(MODULE_NAME, name);
        criteria.add(PARENT_ID, ((Module)group).getParentId());
        List results = BasePeer.doSelect(criteria);
        if(results.size() > 1)
        {
            throw new DataBackendException("Multiple groups named '" +
                name + "' exist!"); //EXCEPTION
        }
        return (results.size()==1);
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public GroupSet getGroups(Criteria criteria)
        throws DataBackendException
    {
        List groups = null;
        try
        {
            groups = ScarabModulePeer.doSelect(criteria);
        }
        catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
        if (groups == null)
        {
            groups = new ArrayList(0);
        }
        return new GroupSet(groups);
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public void saveGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            if (!((Persistent)group).isNew()) 
            {
                group.save();
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized Group addGroup(Group group) 
        throws DataBackendException, EntityExistsException
    {
        try
        {
            lockExclusive();
            if (((Persistent)group).isNew()) 
            {
                group.save();
                // add the group to system-wide cache
                getAllGroups().add(group);
                return group;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        // the only way we could get here without return/throw tirggered
        // is that the groupExists was true.
        throw new EntityExistsException("Group '" + group + 
            "' already exists"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void removeGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            lockExclusive();
            if (!((Persistent)group).isNew()) 
            {
                ((Module)group).setDeleted(true);
                group.save();
                getAllGroups().remove(group);
            }
        }
        catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void renameGroup(Group group, String name)
        throws DataBackendException, UnknownEntityException
    {
        throw new DataBackendException("rename is not supported"); //EXCEPTION

        /* this stuff is cut-n-paste
        boolean groupExists = false;
        try
        {
            lockExclusive();
            groupExists = checkExists(group);
            if(groupExists)
            {
                ((SecurityObject)group).setName(name);
                Criteria criteria = GroupPeer.buildCriteria(group);
                GroupPeer.doUpdate(criteria);
                return;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("renameGroup(Group,String)" ,e);
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'");
        */
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
protected boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        return ScarabModulePeer.checkExists(group);
    }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
public User getAuthenticatedUser(String username, String password)
        throws DataBackendException, UnknownEntityException, 
            PasswordMismatchException {
        LDAPUserInfoCallback info = authenticate(username, password);

        /* First try to auth from ldap */
        if (info != null) {
            /* Check if user exists */
            if (!super.userManager.accountExists(username)) {
                try {
                    super.userManager.createAccount(createUser(username,
                            password, info), password);
                } catch (EntityExistsException e) {
                }

                
            } else {
                User curruser = userManager.retrieve(username);
                copyProps(curruser, info);

                String encrypted = TurbineSecurity.encryptPassword(password);

                if (!encrypted.equals(curruser.getPassword())) {
                    curruser.setPassword(encrypted);
                }

                userManager.store(curruser);
            }

            return userManager.retrieve(username);
        }

        return userManager.retrieve(username, password);
    }
6 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (DataBackendException e)
            {
                log.error("authenticateNtlm: " + e);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (DataBackendException e)
                                {
                                    // maybe the role request was approved 
                                    // by another admin?
                                    AccessControlList acl = su.getACL();
                                    if (acl.hasRole( role, (Group) module ) )
                                    {
                                        hasRoles = true;
                                    }
                                    else
                                    {
                                        // Something went wrong, ignore for now.
                                    }
                                }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (DataBackendException e)
    		{
    			Log.get().error("hasRoleInModule: " + e);
    		}
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
            
// in java/org/tigris/scarab/actions/Login.java
catch (DataBackendException e)
        {
            setAlertMessage(scarabR, L10NKeySet.ExceptionDatabaseGenericError);
            Log.get().error("Error while attempting to log in", e);
            failAction(data, "Login.vm");
            return null;
        }
2 
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
0
unknown (Lib) DataSetException 0 0 43 
            
// in java/org/tigris/scarab/om/MITList.java
public List getAttributes(final boolean activeOnly, final boolean commonOnly)
            throws TorqueException,
            DataSetException
    {

        Set matchingAttributes = new HashSet();
        Iterator iter = iterator();
        while (iter.hasNext())
        {
            final MITListItem item = (MITListItem)iter.next();
            final List rmas = getModule(item).getRModuleAttributes(
                    item.getIssueType());
            for (Iterator i = rmas.iterator(); i.hasNext();)
            {
                final RModuleAttribute rma = (RModuleAttribute) i.next();
                final Attribute att = rma.getAttribute();
                if ((!activeOnly || rma.getActive()))
                {
                    boolean wantedAttribute = (commonOnly) ? isCommon(att,
                            activeOnly) : true;
                    if (size() == 1 || wantedAttribute)
                    {
                        matchingAttributes.add(att);
                    }
                }
            }
            if(commonOnly)
            {
                // don't need to iterate through other Items, because the
                // intersection with the first MITListItem is sufficient
                // to fulfill the commonOnly rule.
                break;
            }
        }

        // Finally copy the resultset into an ArrayList for
        // compatibility to older implementaiton of this method.
        final List result = new ArrayList();
        iter = matchingAttributes.iterator();
        while(iter.hasNext())
        {
            result.add(iter.next());
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonAttributes() throws TorqueException, DataSetException
    {
        return getAttributes(true,true);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonAttributes(final boolean activeOnly) throws TorqueException, DataSetException
    {
        return getAttributes(activeOnly, true);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final Attribute attribute, final boolean activeOnly)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        addToCriteria(
            crit,
            RModuleAttributePeer.MODULE_ID,
            RModuleAttributePeer.ISSUE_TYPE_ID);
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID, attribute.getAttributeId());
        if (activeOnly)
        {
            crit.add(RModuleAttributePeer.ACTIVE, true);
        }

        return size() == RModuleAttributePeer.count(crit);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final Attribute attribute) throws TorqueException, DataSetException
    {
        return isCommon(attribute, true);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonNonUserAttributes() throws TorqueException, DataSetException
    {
        assertNotEmpty();

        final List matchingAttributes = new ArrayList();
        final MITListItem item = getFirstItem();

        final List rmas = getModule(item).getRModuleAttributes(item.getIssueType());
        final Iterator i = rmas.iterator();
        while (i.hasNext())
        {
            final RModuleAttribute rma = (RModuleAttribute) i.next();
            final Attribute att = rma.getAttribute();
            if (!att.isUserAttribute() && rma.getActive() && isCommon(att))
            {
                matchingAttributes.add(att);
            }
        }

        return matchingAttributes;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonOptionAttributes() throws TorqueException, DataSetException
    {
        assertNotEmpty();

        final List matchingAttributes = new ArrayList();
        final MITListItem item = getFirstItem();

        final List rmas = getModule(item).getRModuleAttributes(item.getIssueType());
        final Iterator i = rmas.iterator();
        while (i.hasNext())
        {
            final RModuleAttribute rma = (RModuleAttribute) i.next();
            final Attribute att = rma.getAttribute();
            if (att.isOptionAttribute() && rma.getActive() && isCommon(att))
            {
                matchingAttributes.add(att);
            }
        }

        return matchingAttributes;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<Attribute> getCommonUserAttributes(final boolean activeOnly) 
        throws TorqueException, DataSetException
    {
        List<Attribute> attributes = null;
        if (isSingleModuleIssueType())
        {
            attributes =
                getModule().getUserAttributes(getIssueType(), activeOnly);
        }
        else
        {
            final List<Attribute> matchingAttributes = new ArrayList<Attribute>();
            final MITListItem item = getFirstItem();
            final List<RModuleAttribute> rmas =
                getModule(item).getRModuleAttributes(
                    item.getIssueType(),
                    activeOnly,
                    Module.USER);
            final Iterator<RModuleAttribute> i = rmas.iterator();
            while (i.hasNext())
            {
                final RModuleAttribute rma = i.next();
                final Attribute att = rma.getAttribute();
                if ((!activeOnly || rma.getActive())
                    && isCommon(att, activeOnly))
                {
                    matchingAttributes.add(att);
                }
            }
            attributes = matchingAttributes;
        }
        return attributes;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<Attribute> getCommonUserAttributes() throws TorqueException, DataSetException
    {
        return getCommonUserAttributes(false);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<ScarabUser> getPotentialAssignees(boolean includeCommitters)
        throws TorqueException, DataSetException
    {
        List<ScarabUser> users = new ArrayList<ScarabUser>();
        List<String> perms = getUserAttributePermissions();
        if (includeCommitters && !perms.contains(ScarabSecurity.ISSUE__ENTER))
        {
            perms.add(ScarabSecurity.ISSUE__ENTER);
        }
        if (isSingleModule())
        {
            ScarabUser[] userArray = getModule().getUsers(perms);
            for (int i = 0; i < userArray.length; i++)
            {
                users.add(userArray[i]);
            }
        }
        else
        {
            MITListItem item = getFirstItem();
            ScarabUser[] userArray = getModule(item).getUsers(perms);
            List<Module> modules = getModules();
            for (int i = 0; i < userArray.length; i++)
            {
                boolean validUser = false;
                ScarabUser user = userArray[i];
                for (Iterator<String> j = perms.iterator(); j.hasNext() && !validUser;)
                {
                    validUser = user.hasPermission(j.next(), modules);
                }
                if (validUser)
                {
                    users.add(user);
                }
            }
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<String> getUserAttributePermissions() throws TorqueException, DataSetException
    {
        final List userAttrs = getCommonUserAttributes();
        final List<String> permissions = new ArrayList<String>();
        for (int i = 0; i < userAttrs.size(); i++)
        {
            final String permission = ((Attribute) userAttrs.get(i)).getPermission();
            if (!permissions.contains(permission))
            {
                permissions.add(permission);
            }
        }
        return permissions;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getAllRModuleUserAttributes() 
    throws TorqueException, DataSetException, TurbineSecurityException
    {
        List rmuas = getSavedRMUAs();
        return rmuas;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleUserAttributes() 
        throws TorqueException, DataSetException, TurbineSecurityException
    {
        final List matchingRMUAs = new ArrayList();
        List rmuas = getSavedRMUAs();
        Iterator i = rmuas.iterator();
        final ScarabUser user = getScarabUser();
        while (i.hasNext())
        {
            final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
            final Attribute att = rmua.getAttribute();
            if (isCommon(att, false))
            {
                matchingRMUAs.add(rmua);
            }
        }

        // None of the saved RMUAs are common for these pairs
        // Delete them and seek new ones.
        if (matchingRMUAs.isEmpty())
        {
            i = rmuas.iterator();
            while (i.hasNext())
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                rmua.delete(user);
            }
            final int sizeGoal = 3;
            int moreAttributes = sizeGoal;

            // First try saved RMUAs for first module-issuetype pair
            final MITListItem item = getFirstItem();
            final Module module = getModule(item);
            final IssueType issueType = item.getIssueType();
            rmuas = user.getRModuleUserAttributes(module, issueType);
            // Next try default RMUAs for first module-issuetype pair
            if (rmuas.isEmpty())
            {
                rmuas = module.getDefaultRModuleUserAttributes(issueType);
            }

            // Loop through these and if find common ones, save the RMUAs
            i = rmuas.iterator();
            while (i.hasNext() && moreAttributes > 0)
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                final Attribute att = rmua.getAttribute();
                if (isCommon(att, false) && !matchingRMUAs.contains(rmua))
                {
                    final RModuleUserAttribute newRmua =
                        getNewRModuleUserAttribute(att);
                    newRmua.setOrder(1);
                    newRmua.save();
                    matchingRMUAs.add(rmua);
                    moreAttributes--;
                }
            }

            // if nothing better, go with random common attributes
            moreAttributes = sizeGoal - matchingRMUAs.size();
            if (moreAttributes > 0)
            {
                Iterator attributes = getCommonAttributes(false).iterator();
                int k = 1;
                while (attributes.hasNext() && moreAttributes > 0)
                {
                    Attribute att = (Attribute) attributes.next();
                    boolean isInList = false;
                    i = matchingRMUAs.iterator();
                    while (i.hasNext())
                    {
                        RModuleUserAttribute rmua =
                            (RModuleUserAttribute) i.next();
                        if (rmua.getAttribute().equals(att))
                        {
                            isInList = true;
                            break;
                        }
                    }
                    if (!isInList)
                    {
                        RModuleUserAttribute rmua =
                            getNewRModuleUserAttribute(att);
                        rmua.setOrder(k++);
                        rmua.save();
                        matchingRMUAs.add(rmua);
                        moreAttributes--;
                    }
                }
            }
        }

        return matchingRMUAs;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final AttributeOption option) throws TorqueException, DataSetException
    {
        return isCommon(option, true);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final AttributeOption option, final boolean activeOnly)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        addToCriteria(
            crit,
            RModuleOptionPeer.MODULE_ID,
            RModuleOptionPeer.ISSUE_TYPE_ID);
        crit.add(RModuleOptionPeer.OPTION_ID, option.getOptionId());
        if (activeOnly)
        {
            crit.add(RModuleOptionPeer.ACTIVE, true);
        }

        return size() == RModuleOptionPeer.count(crit);
    }
            
// in java/org/tigris/scarab/om/RModuleAttributePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/ScarabUserImplPeer.java
public static int getUsersCount(final Criteria critCount) 
        throws TorqueException, DataSetException
    {
        final List resultCount = ScarabUserImplPeer.doSelectVillageRecords(critCount);
        final Record record = (Record) resultCount.get(0);                
        return record.getValue(1).asInt();        
    }
            
// in java/org/tigris/scarab/om/IssuePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/IssuePeer.java
public static int countDistinct(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT_DISTINCT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public ScarabPaginatedList getUsers(final String name, 
                                        final String username, 
                                        final MITList mitList, 
                                        final int pageNum, 
                                        final int resultsPerPage,
                                        final String sortColumn, 
                                        final String sortPolarity,
                                        final boolean includeCommitters)
        throws TorqueException, DataSetException
    {
    	return getUsers(name, username, mitList, pageNum, resultsPerPage, sortColumn, sortPolarity, includeCommitters, false);
    	
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public ScarabPaginatedList getUsers(final String name, 
                                        final String username, 
                                        final MITList mitList, 
                                        final int pageNum, 
                                        final int resultsPerPage,
                                        final String sortColumn, 
                                        final String sortPolarity,
                                        final boolean includeCommitters,
                                        final boolean confirmedOnly)
        throws TorqueException, DataSetException
    {
        final int polarity = sortPolarity.equals("asc") ? 1 : -1; 
        List result = null;
        ScarabPaginatedList paginated = null; 

        final Comparator c = new Comparator() 
        {
            public int compare(Object o1, Object o2) 
            {
                int i = 0;
                if ("username".equals(sortColumn))
                {
                    i =  polarity * ((ScarabUser)o1).getUserName()
                              .compareTo(((ScarabUser)o2).getUserName());
                }
                else
                {
                    i =  polarity * ((ScarabUser)o1).getName()
                             .compareTo(((ScarabUser)o2).getName());
                }
                return i;
             }
        };

            final Criteria crit = new Criteria();//
            final Criteria critCount = new Criteria();
            critCount.addSelectColumn("COUNT(DISTINCT " + TurbineUserPeer.USERNAME + ")");
            if (mitList != null)
            {
                final List modules = mitList.getModules();
                for (Iterator it = modules.iterator(); it.hasNext(); )
                {
                    final Module mod = (Module)it.next();
                    final List perms = mitList.getUserAttributePermissions();
                    if (includeCommitters && !perms.contains(org.tigris.scarab.services.security.ScarabSecurity.ISSUE__ENTER))
                    {
                        perms.add(org.tigris.scarab.services.security.ScarabSecurity.ISSUE__ENTER);
                    }

                    crit.addIn(TurbinePermissionPeer.PERMISSION_NAME, perms);
                    crit.setDistinct();
                    critCount.addIn(TurbinePermissionPeer.PERMISSION_NAME, perms);
                }
                crit.addIn(TurbineUserGroupRolePeer.GROUP_ID, mitList.getModuleIds());
                critCount.addIn(TurbineUserGroupRolePeer.GROUP_ID, mitList.getModuleIds());
            }
            crit.addJoin(TurbineUserPeer.USER_ID, TurbineUserGroupRolePeer.USER_ID);
            crit.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePermissionPeer.ROLE_ID);
            crit.addJoin(TurbineRolePermissionPeer.PERMISSION_ID, TurbinePermissionPeer.PERMISSION_ID);
            critCount.addJoin(TurbineUserPeer.USER_ID, TurbineUserGroupRolePeer.USER_ID);
            critCount.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePermissionPeer.ROLE_ID);
            critCount.addJoin(TurbineRolePermissionPeer.PERMISSION_ID, TurbinePermissionPeer.PERMISSION_ID);            

			//user by name
            if (name != null)
            {
                int nameSeparator = name.indexOf(" ");
                if (nameSeparator != -1) 
                {
                    final String firstName = name.substring(0, nameSeparator);
                    final String lastName = name.substring(nameSeparator+1, name.length());
                    crit.add(ScarabUserImplPeer.FIRST_NAME, 
                             addWildcards(firstName), Criteria.LIKE);
                    crit.add(ScarabUserImplPeer.LAST_NAME, 
                             addWildcards(lastName), Criteria.LIKE);
                    critCount.add(ScarabUserImplPeer.FIRST_NAME, 
                            addWildcards(firstName), Criteria.LIKE);
                    critCount.add(ScarabUserImplPeer.LAST_NAME, 
                            addWildcards(lastName), Criteria.LIKE);
                    
                }
                else 
                {
                    String[] tableAndColumn = StringUtils.split(ScarabUserImplPeer.FIRST_NAME, ".");
                    final Criteria.Criterion fn = crit.getNewCriterion(tableAndColumn[0],
                                                                 tableAndColumn[1], 
                                                                 addWildcards(name), 
                                                                 Criteria.LIKE);
                    tableAndColumn = StringUtils.split(ScarabUserImplPeer.LAST_NAME, ".");
                    final Criteria.Criterion ln = crit.getNewCriterion(tableAndColumn[0],
                                                                 tableAndColumn[1], 
                                                                 addWildcards(name), 
                                                                 Criteria.LIKE);
                    fn.or(ln);
                    crit.add(fn);
                    critCount.add(fn);
                }
            }

            if (username != null)
            {
                crit.add(ScarabUserImplPeer.LOGIN_NAME, 
                         addWildcards(username), Criteria.LIKE);
                critCount.add(ScarabUserImplPeer.LOGIN_NAME, 
                        addWildcards(username), Criteria.LIKE);
            }
            
            String col = ScarabUserImplPeer.FIRST_NAME;
            if (sortColumn.equals("username"))
                col = ScarabUserImplPeer.USERNAME;
            if (sortPolarity.equals("asc"))
            {
                crit.addAscendingOrderByColumn(col);
            }
            else
            {
                crit.addDescendingOrderByColumn(col);
            }
            
            //confirmed users only
            if(confirmedOnly){
            	crit.add(ScarabUserImplPeer.CONFIRM_VALUE, (Object)"CONFIRMED", Criteria.EQUAL);
            }

			//finish query
            final int totalResultSize = ScarabUserImplPeer.getUsersCount(critCount);
            
            crit.setOffset((pageNum - 1)* resultsPerPage);
            crit.setLimit(resultsPerPage);
            result = ScarabUserImplPeer.doSelect(crit);

            // if there are results, sort the result set
            if (totalResultSize > 0 && resultsPerPage > 0)
            {

                paginated = new ScarabPaginatedList(result, totalResultSize,
                                                    pageNum,
                                                    resultsPerPage);
            }
            else 
            {
                paginated = new ScarabPaginatedList();
            }
        
        return paginated;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public int getIssueCount(ScarabUser user, AttributeOption attributeOption)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();

        Integer attributeId = attributeOption.getAttributeId();
        Integer optionId    = attributeOption.getOptionId();

        crit.add(AttributeValuePeer.ATTRIBUTE_ID, attributeId);
        crit.add(AttributeValuePeer.OPTION_ID,optionId);
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.MOVED, 0);
        crit.add(IssuePeer.DELETED, 0);
        crit.add(IssuePeer.ID_COUNT, 0, SqlEnum.GREATER_THAN);
        crit.addJoin(AttributeValuePeer.ISSUE_ID, IssuePeer.ISSUE_ID);
        crit.add(AttributeValuePeer.DELETED,0);
        int count = AttributeValuePeer.count(crit);
        return count;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public int getIssueCount(ScarabUser user)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.DELETED,0);
        crit.add(IssuePeer.MOVED,0);
        crit.add(IssuePeer.ID_COUNT, 0, SqlEnum.GREATER_THAN);
        int count = IssuePeer.count(crit);
        return count;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean hasIssues()
        throws TorqueException, DataSetException
    {
        return hasIssues((Module) null);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean hasIssues(Module module)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();
        crit.add(IssuePeer.TYPE_ID, getIssueTypeId());
        if (module != null)
        {
            crit.add(IssuePeer.MODULE_ID, module.getModuleId());
        }
        return (IssuePeer.count(crit) > 0);
    }
            
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user, AttributeOption attributeOption)
        throws TorqueException, ScarabException, DataSetException
    {
        Criteria crit = new Criteria();

        Integer attributeId = attributeOption.getAttributeId();
        Integer optionId    = attributeOption.getOptionId();

        crit.add(AttributeValuePeer.ATTRIBUTE_ID, attributeId);
        crit.add(AttributeValuePeer.OPTION_ID,optionId);
        crit.add(AttributeValuePeer.DELETED,0);
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.TYPE_ID,this.getIssueTypeId());
        crit.add(IssuePeer.MOVED, 0);
        crit.add(IssuePeer.DELETED, 0);
        crit.addJoin(AttributeValuePeer.ISSUE_ID, IssuePeer.ISSUE_ID);

        int count = AttributeValuePeer.count(crit);
        return count;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean hasAttributes(final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.addSelectColumn("count(" + RModuleAttributePeer.ATTRIBUTE_ID + ")");
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean includesIssueType(final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleIssueTypePeer.MODULE_ID,
                 getModuleId());
        crit.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
                 issueType.getIssueTypeId());
        return RModuleIssueTypePeer.count(crit) > 0;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void setInitialAttributesAndIssueTypes()
        throws TorqueException, DataSetException, ScarabException
    {
        isInitializing = true;
        ValidationException ve = null;
        try
        {
        // Add defaults for issue types and attributes 
        // from parent module
        final Module parentModule = ModuleManager.getInstance(getParentId());
        if(parentModule != null && parentModule.getModuleId().intValue() != 0){
        	inheritFromParent(parentModule);  //don't inherit anything from global data/module
        }
        
        final List defaultIssueTypes = IssueTypePeer.getDefaultIssueTypes();
        for (int i=0; i< defaultIssueTypes.size(); i++)
        {
            final IssueType defaultIssueType = (IssueType)defaultIssueTypes.get(i);
            if (!includesIssueType(defaultIssueType))
            {
                try
                {
                    addIssueType(defaultIssueType);
                }
                catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
            }
        }
        }
        finally
        {
            isInitializing = false;
        }
        if (ve != null) 
        {
            throw ve;
        }
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public List getCompatibleAttributeTypes()
        throws TorqueException, DataSetException
    {
        List result = null;
        final Object obj = ScarabCache.get(this, GET_COMPATIBLE_ATTRIBUTE_TYPES); 
        if (obj == null) 
        {
            boolean inUse = !isNew();
            if (inUse) 
            {
                // check to see if attribute really has been used
                final Criteria crit = new Criteria();
                crit.add(AttributeValuePeer.ATTRIBUTE_ID, getAttributeId());
                inUse = AttributeValuePeer.count(crit) > 0; 
            }
            if (inUse) 
            {
                if (isTextAttribute()) 
                {
                    final Criteria crit = new Criteria();
                    crit.addIn(AttributeTypePeer.ATTRIBUTE_TYPE_ID, AttributeTypePeer.TEXT_PKS);
                    result = AttributeTypePeer.doSelect(crit);                
                }
                else if (this.isOptionAttribute())
                {
                    final Criteria crit = new Criteria();
                    crit.addIn(AttributeTypePeer.ATTRIBUTE_TYPE_ID, AttributeTypePeer.OPTION_PKS);
                    result = AttributeTypePeer.doSelect(crit);                
                }
                else 
                {
                    result = Collections.EMPTY_LIST;
                }
            }
            else 
            {
                result = getAllAttributeTypes();
            }
            ScarabCache.put(result, this, GET_COMPATIBLE_ATTRIBUTE_TYPES);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasModuleMappings()
        throws TorqueException, DataSetException
    {
        return hasMapping((Module) null, (IssueType) null);
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasMapping(final Module module, final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        if (module != null)
        {
            crit.add(RModuleAttributePeer.MODULE_ID,
                     module.getModuleId());
        }
        if (issueType != null)
        {
            crit.add(RModuleAttributePeer.ISSUE_TYPE_ID,
                     issueType.getIssueTypeId());
        }
        crit.addSelectColumn("count(" + RModuleAttributePeer.ATTRIBUTE_ID + ")");
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasGlobalIssueTypeMappings()
        throws TorqueException, DataSetException
    {
        return hasGlobalMapping((IssueType) null);
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasGlobalMapping(IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        if (issueType != null)
        {
            crit.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
                     issueType.getIssueTypeId());
        }
        crit.addSelectColumn("count(" + RIssueTypeAttributePeer.ATTRIBUTE_ID
                             + ')');
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public static List parseIssueList(final Module module, final String theList)
        throws TorqueException, DataSetException
    {
        final String[] issues = StringUtils.split(theList, ",");
        final List results = new ArrayList();
        for (int i = 0; i < issues.length; i++)
        {
            if (issues[i].indexOf('*') != -1)
            {
                // Probably better to use more Torque here, but this
                // is definitely going to be faster and more
                // efficient.
                final String sql = "SELECT CONCAT(" + IssuePeer.ID_PREFIX + ',' +
                    IssuePeer.ID_COUNT + ") FROM " + IssuePeer.TABLE_NAME +
                    " WHERE " + IssuePeer.ID_PREFIX + " = '" +
                    module.getCode() + '\'';
                final List records = BasePeer.executeQuery(sql);
                for (Iterator j = records.iterator(); j.hasNext();)
                {
                    final Record rec = (Record)j.next();
                    results.add(rec.getValue(1).asString());
                }
            }
            // check for a -
            else if (issues[i].indexOf('-') == -1)
            {
                // Make sure user is not trying to access issues from another
                // module.
                final FederatedId fid = createFederatedId(module, issues[i]);
                if (!fid.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    final String[] args = { fid.getPrefix(), module.getCode() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixNotForModule", args)); //EXCEPTION
                }
                results.add(issues[i]);
            }
            else
            {
                final String[] issue = StringUtils.split(issues[i], "-");
                if (issue.length != 2)
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDRangeNotValid", issues[i])); //EXCEPTION
                }
                FederatedId fidStart = createFederatedId(module, issue[0]);
                FederatedId fidStop = createFederatedId(module, issue[1]);
                if (!fidStart.getPrefix().equalsIgnoreCase(module.getCode()) ||
                    !fidStop.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesNotForModule",
                                         module.getCode())); //EXCEPTION
                }
                else if (!fidStart.getPrefix()
                         .equalsIgnoreCase(fidStop.getPrefix()))
                {
                    final String[] args = { fidStart.getPrefix(),
                                      fidStop.getPrefix() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesDoNotMatch", args)); //EXCEPTION
                }
                else if (fidStart.getCount() > fidStop.getCount())
                {
                    FederatedId swap = fidStart;
                    fidStart = fidStop;
                    fidStop = swap;
                }

                for (int j = fidStart.getCount(); j <= fidStop.getCount();j++)
                {
                    results.add(fidStart.getPrefix() + j);
                }
            }
        }
        return results;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasAnySearchableRMITs()
        throws TorqueException, DataSetException    
    {
        return internalUser.hasAnySearchableRMITs();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public boolean hasAnySearchableRMITs()
        throws TorqueException, DataSetException    
    {
        boolean result = false;
        final List moduleIds = getSearchableModuleIds();
        if (!moduleIds.isEmpty()) 
        {
            final Criteria crit = new Criteria();
            crit.addIn(RModuleIssueTypePeer.MODULE_ID, moduleIds);
            result = (RModuleIssueTypePeer.count(crit) > 0);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/RModuleOptionPeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/RModuleIssueTypePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)AttributeValuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static int countDistinct(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT_DISTINCT);
        return ((Record)AttributeValuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/feeds/QueryFeed.java
public SyndFeed getFeed() throws Exception, TorqueException, DataSetException, TurbineSecurityException
    {
        SyndFeed feed = new SyndFeedImpl();
        feed.setTitle(query.getName());
        String link = scarabLink.setAction("Search").addPathInfo("go",query.getQueryId()).toString();
        feed.setLink(link);
        feed.setDescription(query.getDescription());
        List entries = new ArrayList();
        for(Iterator i = results.iterator(); i.hasNext();)
        {
            SyndEntry entry = new SyndEntryImpl();
            SyndContent description = new SyndContentImpl();
            QueryResult queryResult = (QueryResult)i.next();
            String title = queryResult.getUniqueId();
            entry.setTitle(title);
            
            Issue issue = IssueManager.getInstance(Long.valueOf(queryResult.getIssueId()));

            link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
            entry.setLink(link);

            Date publishedDate = null;
            if(issue.getModifiedDate()!= null){
                publishedDate = issue.getModifiedDate();
            }
            else {
                publishedDate = issue.getCreatedDate();
            }
            entry.setPublishedDate(publishedDate);

            description = new SyndContentImpl();
            description.setType("text/html");
            String desc = "";
            Iterator avIteratorCSV = queryResult.getAttributeValuesAsCSV().iterator();
            Iterator avIterator = query.getMITList().getAllRModuleUserAttributes().iterator();
            while (avIterator.hasNext())
            {
                String value = (String)avIteratorCSV.next();
                RModuleUserAttribute av = (RModuleUserAttribute)avIterator.next();
                desc = desc + "<b>" + av.getAttribute().getName()+":</b>" + value +"<br/>";
            }
            description.setValue(ScarabUtil.filterNonXml(desc));

            entry.setDescription(description);
            entries.add(entry);
        }
        feed.setEntries(entries);
        feed.setFeedType(format);
        return feed;
    }
1 
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }
1 
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }
1
unknown (Lib) EmailException 3 
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
public String send()
        throws EmailException
    {
        context.put("mail", this);

        String htmlbody = "";
        String textbody = "";

        // Create MessageBody from template:
        try
        {
            if (htmlTemplate != null)
            {
                htmlbody = handleRequest(htmlTemplate, true);
            }
            if (textTemplate != null)
            {
                textbody = handleRequest(textTemplate, false);
            }                    
        }
        catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }

        // Set appropriate Message body:
        try
        {
            if (StringUtils.isNotEmpty(htmlbody) && StringUtils.isNotEmpty(textbody))
            {
                // We have both plain text and HTML message bodys
                setHtmlMsg(htmlbody); 
                setTextMsg(textbody); 
            }
            else if (StringUtils.isEmpty(htmlbody)) 
            {
                // We have only a text body.
                setTextMsg(textbody);
                /* Note that we don't use setMsg() because that would put the plain
                 * text into a <html><pre>[plain text]</pre></html> stansa in the
                 * HTML part. Not particularly useful. Worse, it also defeats any 
                 * hyperlinks in the message.
                 */
            }
            else
            {
                // We have only a HTML message. Recipients with a text-only client
                // won't like this.
                setHtmlMsg(htmlbody); 
            }
        }
        catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }


        // Send message to recipients:
        String mimeMessageId = null;
        try
        {
            mimeMessageId = super.send();
            logSend();
        }
        catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
        
        return mimeMessageId;
    }
3 
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
1 
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
public String send()
        throws EmailException
    {
        context.put("mail", this);

        String htmlbody = "";
        String textbody = "";

        // Create MessageBody from template:
        try
        {
            if (htmlTemplate != null)
            {
                htmlbody = handleRequest(htmlTemplate, true);
            }
            if (textTemplate != null)
            {
                textbody = handleRequest(textTemplate, false);
            }                    
        }
        catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }

        // Set appropriate Message body:
        try
        {
            if (StringUtils.isNotEmpty(htmlbody) && StringUtils.isNotEmpty(textbody))
            {
                // We have both plain text and HTML message bodys
                setHtmlMsg(htmlbody); 
                setTextMsg(textbody); 
            }
            else if (StringUtils.isEmpty(htmlbody)) 
            {
                // We have only a text body.
                setTextMsg(textbody);
                /* Note that we don't use setMsg() because that would put the plain
                 * text into a <html><pre>[plain text]</pre></html> stansa in the
                 * HTML part. Not particularly useful. Worse, it also defeats any 
                 * hyperlinks in the message.
                 */
            }
            else
            {
                // We have only a HTML message. Recipients with a text-only client
                // won't like this.
                setHtmlMsg(htmlbody); 
            }
        }
        catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }


        // Send message to recipients:
        String mimeMessageId = null;
        try
        {
            mimeMessageId = super.send();
            logSend();
        }
        catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
        
        return mimeMessageId;
    }
1 
            
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
1 
            
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
0
unknown (Lib) EntityExistsException 1 
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized Group addGroup(Group group) 
        throws DataBackendException, EntityExistsException
    {
        try
        {
            lockExclusive();
            if (((Persistent)group).isNew()) 
            {
                group.save();
                // add the group to system-wide cache
                getAllGroups().add(group);
                return group;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        // the only way we could get here without return/throw tirggered
        // is that the groupExists was true.
        throw new EntityExistsException("Group '" + group + 
            "' already exists"); //EXCEPTION
    }
0 2 
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void createNewUser()
        throws TorqueException, DataBackendException, EntityExistsException
    {
        // get a unique id for validating the user
        final String uniqueId = RandomStringUtils
                .randomAlphanumeric(UNIQUE_ID_MAX_LEN);
        // add it to the perm table
        setConfirmed(uniqueId);
        TurbineSecurity.addUser (this, getPassword());
        setPasswordExpire();
        
        // add any roles the anonymous user has, if she is enabled.
        if(ScarabUserManager.anonymousAccessAllowed())
        {
            final ScarabUserImpl anonymous = (ScarabUserImpl) ScarabUserManager.getAnonymousUser();
            final List/*<ScarabModule>*/ modules = anonymous.getNonGlobalModules();
            for(Iterator it0 = modules.iterator(); it0.hasNext(); )
            {
                final ScarabModule module = (ScarabModule)it0.next();
                final List/*<Roles>*/ roles = anonymous.getRoles(module);
                for(Iterator it1 = roles.iterator(); it1.hasNext(); )
                {
                    try 
                    {
                        final Role role = (Role) it1.next();
                        TurbineSecurity.grant(this, (Group) module, role);

                        // TODO: Needs to be refactored into the Users system?
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.GET_ACL);
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable) role, module);
                        
                    }catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized Group addGroup(Group group) 
        throws DataBackendException, EntityExistsException
    {
        try
        {
            lockExclusive();
            if (((Persistent)group).isNew()) 
            {
                group.save();
                // add the group to system-wide cache
                getAllGroups().add(group);
                return group;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        // the only way we could get here without return/throw tirggered
        // is that the groupExists was true.
        throw new EntityExistsException("Group '" + group + 
            "' already exists"); //EXCEPTION
    }
4 
            
// in java/org/tigris/scarab/actions/Register.java
catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("RoleExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
            
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (EntityExistsException e) {
                }
0 0
runtime (Lib) Error 1 
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private void initVelocity()
        throws InitializationException
    {
        // Now we have to perform a couple of path translations
        // for our log file and template paths.
        String path = getRealPath(
            getConfiguration().getString(VelocityEngine.RUNTIME_LOG, null));

        if (path != null && path.length() > 0)
        {
            getConfiguration().setProperty(VelocityEngine.RUNTIME_LOG, path);
        }
        else
        {
            String msg = EmailService.SERVICE_NAME + " runtime log file " +
                "is misconfigured: '" + path + "' is not a valid log file";

            throw new Error(msg); //EXCEPTION
        }

        // Get all the template paths where the velocity
        // runtime should search for templates and
        // collect them into a separate vector
        // to avoid concurrent modification exceptions.
        String key;
        List keys = new ArrayList();
        for (Iterator i = getConfiguration().getKeys(); i.hasNext();)
        {
            key = (String) i.next();
            if (key.endsWith(RESOURCE_LOADER_PATH))
            {
                keys.add(key);
            }
        }

        // Loop through all template paths, clear the corresponding
        // velocity properties and translate them all to the webapp space.
        int ind;
        List paths;
        String entry;
        for (Iterator i = keys.iterator(); i.hasNext();)
        {
            key = (String) i.next();
            paths = getConfiguration().getList(key,null);
            if (paths != null)
            {
                velocityEngine.clearProperty(key);
                getConfiguration().clearProperty(key);

                for (Iterator j = paths.iterator(); j.hasNext();)
                {
                    path = (String) j.next();
                    if (path.startsWith(JAR_PREFIX + "file"))
                    {
                        // A local jar resource URL path is a bit more
                        // complicated, but we can translate it as well.
                        ind = path.indexOf("!/");
                        if (ind >= 0)
                        {
                            entry = path.substring(ind);
                            path = path.substring(9,ind);
                        }
                        else
                        {
                            entry = "!/";
                            path = path.substring(9);
                        }
                        path = JAR_PREFIX + "file:" + getRealPath(path) +
                            entry;
                    }
                    else if (path.startsWith(ABSOLUTE_PREFIX))
                    {
                        path = path.substring (ABSOLUTE_PREFIX.length(),
                                               path.length());
                    }
                    else if (!path.startsWith(JAR_PREFIX))
                    {
                        // But we don't translate remote jar URLs.
                        path = getRealPath(path);
                    }
                    // Put the translated paths back to the configuration.
                    getConfiguration().addProperty(key,path);
                }
            }
        }

        try
        {
            velocityEngine.setExtendedProperties(ConfigurationConverter
                    .getExtendedProperties(getConfiguration()));

            velocityEngine.init();
        }
        catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
    }
0 0 1 
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Error err)
        {
            error = err;
            throw err;
        }
1 
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Error err)
        {
            error = err;
            throw err;
        }
0
checked (Lib) Exception 12 
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
			throws Exception {
		super.doBuildTemplate(data, context);

		data.getResponse().setContentType(MIME_TYPE);

		// we will send the response, so no target to render
		data.setTarget(null);
		
		Writer writer = data.getResponse().getWriter();
		
		try {
            ParameterParser parser = data.getParameters();



            String feedType = parser.getString(FEED_TYPE_KEY);
            if(feedType == null)
            {
                String msg = COULD_NOT_FIND_FEED_TYPE;
                Log.get().error(msg);
                data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);            
                return;
            }

            String feedFormat = parser.getString(FEED_FORMAT_KEY);

            ScarabLink scarabLink= getScarabLinkTool(context);
            
            Feed feedSource = null;
            if (feedType.equals("IssueFeed")){
                String issueId = parser.getString(ISSUE_ID_KEY);                
                if(issueId.equals("")){
                    throw new IllegalArgumentException("Issue ID is missing.  Should be appended like: /issueId/xxx");
                }            	
            	Issue issue = IssueManager.getIssueById(issueId);
            	feedSource = new IssueFeed(issue,scarabLink, getLocalizationTool(context));
            }
            else {
            	throw new Exception("Couldn't find feed for type:" + feedType);
            }
            SyndFeed feed = feedSource.getFeed();

            feedFormat = (feedFormat!=null) ? feedFormat : DEFAULT_FEED_FORMAT;
            feed.setFeedType(feedFormat);

            
            SyndFeedOutput output = new SyndFeedOutput();
            output.output(feed,writer);
        }
        catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }        
        catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }      		
	}
            
// in java/org/tigris/scarab/actions/TemplateList.java
public void doDeletetemplates(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Object[] keys = data.getParameters().getKeys();
        String key;
        String templateId;
        ScarabUser user = (ScarabUser)data.getUser();
        boolean atLeastOne = false;
        boolean success = true;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
                atLeastOne = true;
                templateId = key.substring(7);
                try
                {
                    Issue issue = IssueManager
                       .getInstance(new NumberKey(templateId), false);
                    if (issue == null)
                    {
                        throw new Exception(
                            l10n.get("CouldNotLocateTemplateToDelete")); //EXCEPTION
                    }
                    issue.deleteItem(user);
                }
                catch (ScarabException e)
                {
                    success = false;
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
                catch (Exception e)
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.getMessage(e));
                }
            }
        } 
        if (!atLeastOne)
        {
            scarabR.setAlertMessage(L10NKeySet.NoTemplateSelected);
        }
        else if (success)
        {
            scarabR.setConfirmMessage(L10NKeySet.TemplateDeleted);
        } 
    }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
public void doUpdate(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        if (intake.isAllValid())
        {
            Module me = null;
            try
            {
                me = scarabR.getModule();
            }
            catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }

            Group moduleGroup = intake.get
                ("Module",me.getQueryKey(), false);

            if (moduleGroup == null)
            {
                setTarget(data, template);
                scarabR.setAlertMessage(
                    L10NKeySet.CouldNotLocateModuleGroup);
                return;
            }
            else
            {
                ScarabUser user = (ScarabUser) data.getUser();

                // make sure that the user has Edit permission 
                // in the module.
                if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, me))
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                    intake.remove(moduleGroup);
                    setTarget(data, nextTemplate);
                    return;
                }

                Module origParent = me.getParent();
                String origCode = me.getCode();
                moduleGroup.setProperties(me);
                Module newParent = me.getParent();
                String newCode = me.getCode();

                if (newParent.getParent() == me && origParent!=me)
                {
                    scarabR.setAlertMessage(L10NKeySet.CircularParentChildRelationship);
                    intake.remove(moduleGroup);
                    setTarget(data, template);
                    return;
                }
                else if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, origParent) && 
                    origParent.getModuleId() != newParent.getModuleId())
                {
                    scarabR.setAlertMessage(L10NKeySet.NoPermissionInParentModule);
                    setTarget(data, template);
                    return;
                }
                
                // Cascade update the code to the (denormalized) issue prefix
                if (! newCode.equals(origCode))
                {
                    if (me instanceof ScarabModule)
                    {
                        ScarabModule sm = (ScarabModule)me;
                        List issues = sm.getIssues();
                        for (int i = 0; i < issues.size(); i++)
                        {
                            Issue issue = (Issue)issues.get(i);
                            if (! issue.getIdPrefix().equals(me.getCode()))
                            {
                                issue.setIdPrefix(me.getCode());
                                issue.save();
                            }
                        }
                        //Update the ID table to reflect the module code r
                        // FIXME: Using SQL because IDBroker doesn't have a Peer yet.
                        String idTable = IDBroker.TABLE_NAME.substring(0, 
                                IDBroker.TABLE_NAME.indexOf('.'));
                        String instanceId = GlobalParameterManager
                        .getString(ScarabConstants.INSTANCE_ID);
                        String sql = "update " + idTable 
                         + " SET TABLE_NAME='" + instanceId + "-" + newCode + "' WHERE TABLE_NAME='" +
                         instanceId + "-" + origCode + "'";
                        BasePeer.executeStatement(sql);                                                
                    }
                    else
                    {
                        throw new Exception ("Did not get a ScarabModule"); //EXCEPTION
                    }
                }
                
                me.save();

                updateModuleParameters(data, me);
                
                intake.remove(moduleGroup);
                setTarget(data, nextTemplate);
                scarabR.setConfirmMessage(L10NKeySet.ModuleUpdated);
            }
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
public void doCreate(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        if (intake.isAllValid())
        {
            Group moduleGroup = intake.get
                ("Module",IntakeTool.DEFAULT_KEY, false);
            Module me = ModuleManager.getInstance();
            if (moduleGroup == null)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
            moduleGroup.setProperties(me);
            ScarabUser user = (ScarabUser)data.getUser();
            
            // make sure that the user has Edit permission 
            // in the parent module.
            if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, 
                me.getParent()))
            {
                scarabR.setAlertMessage(L10NKeySet.NoPermissionInParentModule);
            }
            else
            {
            	try{
	                me.setOwnerId(user.getUserId());
	                me.save();
	                
	                updateModuleParameters(data, me);
	
	                data.setACL(((ScarabUser)data.getUser()).getACL());
	                data.save();
	
	                scarabR.setConfirmMessage(L10NKeySet.NewModuleCreated);
	                intake.remove(moduleGroup);
            	}
                catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
            }
        }
        else
        {
            setTarget(data, template);
            return;
        }
        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
private void setRequiredFlags(Issue issue, IntakeTool intake,
    		LinkedMap avMap, TemplateContext context)
        throws Exception
    {
        if (issue == null)
        {
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            throw new Exception(l10n.get("IssueNoLongerValid")); //EXCEPTION
        }
        Set selectedOptions = new HashSet();
        Map conditionallyRequiredFields = new HashMap(); 
        IssueType issueType = issue.getIssueType();
        List requiredAttributes = issueType
            .getRequiredAttributes(issue.getModule());
        for (MapIterator iter = avMap.mapIterator(); iter.hasNext();)
        {
            AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            
            Group group = 
                intake.get("AttributeValue", aval.getQueryKey(), false);
            if (group != null) 
            {            
                Field field = null;
                if (aval instanceof OptionAttribute) 
                {
                    field = group.get("OptionId");
                    // Will store the selected optionId, for later query.
                    Object fieldValue = field.getValue();
                    if (null != fieldValue)
                    {
                        selectedOptions.add(fieldValue);
                    }                    
                }
                else if (aval instanceof IntegerAttribute) 
                {
                    field = group.get("NumericValue");
                }
                else if (aval instanceof UserAttribute) 
                {
                    field = group.get("UserId");
                }
                else 
                {
                    field = group.get("Value");
                }

                /**
                 * If the field has any conditional constraint, will be added to the collection
                 * in the hash.
                 */ 
                List conditions = aval.getRModuleAttribute().getConditions(); 
                if (conditions.size() > 0)
                {
                    for (Iterator it = conditions.iterator(); it.hasNext(); )
                    {
                        Condition cond = (Condition)it.next();
                        Integer id = cond.getOptionId();
                        List fields = (List)conditionallyRequiredFields.get(id);
                        if (fields == null)
                        {
                            fields = new ArrayList();
                        }
                        fields.add(field);
                        conditionallyRequiredFields.put(id, fields);
                    }
                }                
                
                for (int j=requiredAttributes.size()-1; j>=0; j--) 
                {
                    if (aval.getAttribute().getPrimaryKey().equals(
                            ((Attribute)requiredAttributes.get(j)).getPrimaryKey())
                        && !aval.isSet())
                    {
                        field.setRequired(true);
                        break;
                    }                    
                }
            }
        }
        /**
         * Now that we have all the info, we will force the 'required' status of any field
         * whose requiredOptionId has been set in the issue.
         */
        for (Iterator requiredIds = conditionallyRequiredFields.keySet().iterator(); requiredIds.hasNext(); )
        {
            Integer attributeId= (Integer)requiredIds.next();
            if (selectedOptions.contains(attributeId))
            {
                List fields = (List)conditionallyRequiredFields.get(attributeId);
                for (Iterator iter = fields.iterator(); iter.hasNext(); )
                {
                    Field field = (Field)iter.next();
            	    if (field.getValue().toString().length() == 0)
            	    {
            	       field.setRequired(true);
            	       field.setMessage("ConditionallyRequiredAttribute");
            	    }
                }
            }
        }        
    }
            
// in java/org/tigris/scarab/actions/admin/AppConfigurationSettings.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        boolean customSettingsChanged = false;
        ParameterParser pp = data.getParameters();
        CompositeConfiguration c = (CompositeConfiguration)Turbine.getConfiguration();
        PropertiesConfiguration customSettings =null;
        for (int i = 0;i<c.getNumberOfConfigurations();i++){
            if(c.getConfiguration(i) instanceof PropertiesConfiguration){
                PropertiesConfiguration pc = (PropertiesConfiguration)c.getConfiguration(i);
                if(pc.getFileName().endsWith("custom.properties")){
                    customSettings = pc;
                    break;
                }
            }
        }
 
        if (customSettings==null){
            throw new Exception("custom.properties file was not defined in TurbineConfiguration.xml");
        }
                
        for (Iterator i =
            IteratorUtils.filteredIterator(
                new EnumerationIterator(pp.keys()),
                new StartsWithPredicate("configuration.key."));
            i.hasNext();
            )
        {
            String key = (String) i.next();
            String realKey = pp.getString(key);
            String value = pp.getString("configuration.value." + realKey);
            
            String turbineValue;
            try
            {
            	turbineValue = Turbine.getConfiguration().getString(realKey);
            }
            catch( ConversionException ce)
            {
            	// This happens, if the Turbine Property is not a String.
            	// This has been seen on JBOSS. Since we can't provide any
            	// reasonable value here, ignore the entry and continue.
            	log.warn("Turbine property ["+realKey+"] is not a String value. No update done. (continue)");
            	turbineValue = null;
            }            
            
            if (turbineValue != null && !turbineValue.equals(value))
            {
                Turbine.getConfiguration().setProperty(realKey,value);                
                customSettings.setProperty(realKey,value);
                customSettingsChanged=true;                
            }
            
        }
        if (customSettingsChanged){
            customSettings.save();
        }
        
        
        getScarabRequestTool(context).setConfirmMessage(L10NKeySet.AppConfigurationChangesSaved);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void validateActivity(final Module moduleOM, 
            final IssueType issueTypeOM,
            final List moduleAttributeList,
            final XmlActivitySet activitySet,
            final XmlActivity activity)
    {
        validateDate(activity.getEndDate(), false);
        if (activity.getOldUser() != null)
        {
            importUsers.add(activity.getOldUser());
        }
        if (activity.getNewUser() != null)
        {
            importUsers.add(activity.getNewUser());
        }
        final XmlAttachment activityAttachment = activity.getAttachment();
        if (activityAttachment != null)
        {
            if (allowFileAttachments &&
                activityAttachment.getReconcilePath() &&
                !new File(activityAttachment.getFilename()).exists())
            {
                final String error = Localization.format
                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                     "CouldNotFindFileAttachment",
                     activityAttachment.getFilename());
                importErrors.add(error);
            }

            validateDate(activityAttachment.getCreatedDate(), true);
            validateDate(activityAttachment.getModifiedDate(), false);

            final String attachCreatedBy = activityAttachment.getCreatedBy();
            if (attachCreatedBy != null)
            {
                importUsers.add(attachCreatedBy);
            }
        }

        // Get the Attribute associated with the Activity
        Attribute attributeOM = null;
        final String activityAttribute = activity.getAttribute();
        try
        {
            attributeOM = Attribute.getInstance(activityAttribute);
            if (attributeOM == null)
            {
                throw new Exception(); //EXCEPTION
            }
        }
        catch (Exception e)
        {
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "CouldNotFindGlobalAttribute", activityAttribute);
            importErrors.add(error);
        }

        if (attributeOM != null)
        {
            if (attributeOM.equals(nullAttribute))
            {
                // Add any dependency activities to a list for later
                // processing.
                if (isDependencyActivity(activity))
                {
                    if (!isDuplicateDependency(activity))
                    {
                        allDependencies.add(activity);
                        LOG.debug("+------------Stored Dependency # " +
                                  allDependencies.size() + '[' + activity.getDependency() + ']');
                    }

                    // Dependency activities don't require further
                    // validation.
                    return;
                }
            }
            else 
                try 
                {
                    if( !attributeOM.isUserAttribute() )
                    {
                        // The null attribute will never be in this list.
                        if (moduleAttributeList != null &&
                            moduleAttributeList.indexOf(attributeOM) < 0)
                        {
                            final String error = Localization.format
                                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                 "CouldNotFindRModuleAttribute", activityAttribute);
                            importErrors.add(error);
                        }
                        else if (activity.getNewOption() != null)
                        {
                            // check for global options
                            AttributeOption attributeOptionOM = null;
                            try
                            {
                                attributeOptionOM = AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                                if (attributeOptionOM == null)
                                {
                                    throw new Exception(); //EXCEPTION
                                }
                            }
                            catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
                            // check for module options
                            try
                            {
                                final RModuleOption rmo = RModuleOptionManager
                                    .getInstance(moduleOM, issueTypeOM,
                                                 attributeOptionOM);
                                if (rmo == null)
                                {
                                    throw new Exception(); //EXCEPTION
                                }
                            }
                            catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
                        }
                        else if (activity.getOldOption() != null)
                        {
                            AttributeOption attributeOptionOM = null;
                            try
                            {
                                attributeOptionOM = AttributeOptionManager
                                    .getInstance(attributeOM, activity.getOldOption());
                                if (attributeOptionOM == null)
                                {
                                    throw new Exception(); //EXCEPTION
                                }
                            }
                            catch (Exception e)
                            {
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption",
                                     activity.getOldOption());
                                importErrors.add(error);
                            }
                            // check for module options
                            try
                            {
                                final RModuleOption rmo = RModuleOptionManager
                                    .getInstance(moduleOM, issueTypeOM,
                                                 attributeOptionOM);
                                if (rmo == null)
                                {
                                    throw new Exception(); //EXCEPTION
                                }
                            }
                            catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
                        }
                    }
                } 
                catch (TorqueException ex) 
                {
                    ex.printStackTrace();
                    importErrors.add(ex);
                }
        }
    }
1 
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
525 
            
// in java/org/tigris/scarab/pipeline/AnonymousLoginValve.java
public void initialize() throws Exception
    {
        anonymousAccessAllowed = ScarabUserManager.anonymousAccessAllowed();
        if (anonymousAccessAllowed) {
            Log.get().info("anonymous Login enabled.");
	        nonAnonymousTargets.add("Register.vm");
	        nonAnonymousTargets.add("ForgotPassword.vm");
        }
        else
        {
            Log.get().info("anonymous Login disabled.");
        }
    }
            
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve22.java
public void initialize() throws Exception{
        super.initialize();
        REQUIRED_CHARSET = Turbine.getConfiguration().
        getString("locale.default.charset",null);
    }
            
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve.java
public void initialize() throws Exception{
        super.initialize();
        REQUIRED_CHARSET = Turbine.getConfiguration().
        getString("locale.default.charset",null);
    }
            
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
public void initialize() throws Exception{
        super.initialize();
        KEY = TimingInfoValve.class.getName() + ".start";

    }
            
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
private void storePreferredLocale(ScarabUser user, String localeAsString)
        throws Exception
    {
    	// Change the settings in the database
        UserPreference pref =
            UserPreferenceManager.getInstance(user.getUserId());
        pref.setLocale(localeAsString);
        pref.save();

        // The internal user caches the current locale,
        // hence we need to modify the user's locale now.
		Locale locale = Localization.getLocale(localeAsString);
        user.setLocale(locale);
    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
public void initialize() throws Exception {
        XMIT_SCREENS.put("IssueTypeList.vm", null);
        XMIT_SCREENS.put("AdvancedQuery.vm", null);
        XMIT_SCREENS.put("Search.vm", null);
        XMIT_SCREENS.put("IssueList.vm", null);
        XMIT_SCREENS.put("RSSDataExport.vm", null);
        XMIT_SCREENS.put("RSSIssueList.vm", null);
        XMIT_SCREENS.put("ViewIssue.vm", null);
        XMIT_SCREENS.put("QueryList.vm", null);
        XMIT_SCREENS.put("SaveQuery.vm", null);
        XMIT_SCREENS.put("EditQuery.vm", null);
        XMIT_SCREENS.put("UserList.vm", null);
        XMIT_SCREENS.put("ConfigureIssueList.vm", null);
        XMIT_SCREENS.put("EditXModuleList.vm", null);
        XMIT_SCREENS.put("reports,Info.vm", null);
        XMIT_SCREENS.put("reports,ConfineDataset.vm", null);
        XMIT_SCREENS.put("reports,XModuleList.vm", null);
        XMIT_SCREENS.put("reports,AxisConfiguration.vm", null);
        XMIT_SCREENS.put("reports,Report_1.vm", null);
        // this is not a real .vm file, but a pointer to a java screen class
        XMIT_SCREENS.put("IssueListExport.vm", null);
        
    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentModule(ScarabUser user, RunData data)
        throws TurbineException, Exception
    {
        Module module = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_MODULE);
        if (key != null) 
        {
            try
            {
                module = ModuleManager.getInstance(new Integer(key));
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else if (parameters.getString("id") != null) 
        {
            try  
            {
                module = IssueManager.getIssueById(parameters.getString("id")).getModule();
                parameters.setString(ScarabConstants.CURRENT_MODULE, 
                             module.getQueryKey());
            }
            catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
        }
        if(module!=null)
        {
            user.setCurrentModule(module);
        }
    }
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
public void initialize() throws Exception
    {
        bNTLMActive = Turbine.getConfiguration().getBoolean("scarab.login.ntlm.active", false);
        domainController = Turbine.getConfiguration().getString("scarab.login.ntlm.domain", "<check properties>");
        Config.setProperty("jcifs.util.loglevel", log.isDebugEnabled()?"10":"0");        
        Config.setProperty("jcifs.smb.client.soTimeout", "300000");
        Config.setProperty("jcifs.netbios.cachePolicy", "600");
        Config.setProperty("jcifs.http.domainController", domainController);
        Config.setProperty("jcifs.smb.client.domain", domainController);
        Config.setProperty("http.auth.ntlm.domain", domainController);        

        if( domainController == null )
        {
            bNTLMActive = false;
            Log.get(this.getClass().getName()).debug("Domain controller must be specified.");
        }
        super.initialize();
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeOption getAttributeOption()
        throws Exception
    {
        if (attributeOption == null)
        {
            String optId = getIntakeTool()
                .get("AttributeOption", IntakeTool.DEFAULT_KEY)
                .get("OptionId").toString();
            if (optId == null || optId.length() == 0)
            {
                attributeOption = AttributeOptionManager.getInstance();
            }
            else
            {
                attributeOption = AttributeOptionManager
                    .getInstance(new Integer(optId));
            }
        }
        return attributeOption;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Attribute getAttribute()
        throws Exception
    {
        try
        {
            if (attribute == null)
            {
                String attId = getIntakeTool()
                    .get("Attribute", IntakeTool.DEFAULT_KEY)
                    .get("Id").toString();
                if (attId == null || attId.length() == 0)
                {
                    attId = data.getParameters().getString("attId");
                    if (attId == null || attId.length() == 0)
                    {
                        attribute = AttributeManager.getInstance();
                    }
                    else
                    {
                        attribute = AttributeManager.getInstance(new Integer(attId));
                    }
                }
                else
                {
                    attribute = AttributeManager.getInstance(new Integer(attId));
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return attribute;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Attribute getAttribute(Integer attrId)
     throws Exception
    {
        this.attribute = AttributeManager.getInstance(attrId);
        return this.attribute;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeOption getAttributeOption(Integer pk)
     throws Exception
    {
        try
        {
           attributeOption = AttributeOptionManager.getInstance(pk);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return attributeOption;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeOption getAttributeOption(String key)
         throws Exception
    {
        return getAttributeOption(new Integer(key));
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueTemplateInfo getIssueTemplateInfo()
        throws Exception
    {
        try
        {
            if (templateInfo == null)
            {
                String templateId = data.getParameters()
                    .getString("templateId");

                if (templateId == null || templateId.length() == 0)
                {
                    templateInfo = IssueTemplateInfo.getInstance();
                }
                else
                {
                    templateInfo = IssueTemplateInfoManager
                        .getInstance(new NumberKey(templateId), false);
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return templateInfo;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Issue getIssueTemplate()
     throws Exception
    {
        Issue template = null;
        String templateId = data.getParameters()
            .getString("templateId");
        try
        {
            if (templateId == null || templateId.length() == 0)
            {
                IssueType issueType = getCurrentIssueType();
                Integer templateID  = issueType.getTemplateId();
                if(templateID.intValue()!=0)
                {
                    IssueType finalIssueType = getIssueType(templateID.toString());
                    template = getCurrentModule().getNewIssue(finalIssueType);
                }
            }
            else
            {
                template = IssueManager
                    .getInstance(new NumberKey(templateId), false);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return template;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Issue getIssueTemplate(String templateId)
        throws Exception
    {
        Issue template = null;
        try
        {
            if (templateId == null || templateId.length() == 0)
            {
                setAlertMessage(L10NKeySet.NoTemplateId);
            }
            else
            {
                template = IssueManager
                    .getInstance(new NumberKey(templateId), false);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return template;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Depend getDepend()
     throws Exception
    {
        try
        {
            if (depend == null)
            {
                String dependId = getIntakeTool()
                    .get("Depend", IntakeTool.DEFAULT_KEY).get("Id").toString();
                if (dependId == null || dependId.length() == 0)
                {
                    depend = DependManager.getInstance();
                }
                else
                {
                    depend = DependManager
                        .getInstance(new NumberKey(dependId), false);
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return depend;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Attachment getAttachment()
        throws Exception
    {
		try
		{
	        if (attachment == null)
	        {
	            Group att = getIntakeTool()
	                .get("Attachment", IntakeTool.DEFAULT_KEY, false);
	            if (att != null)
	            {
	                String attId =  att.get("Id").toString();
	                if (attId == null || attId.length() == 0)
	                {
	                    attachment = new Attachment();
	                }
	                else
	                {
	                    attachment = AttachmentManager
	                        .getInstance(new NumberKey(attId), false);
	                }
	            }
	            else
	            {
	                attachment = new Attachment();
	            }
	        }
		}
		catch(Exception e)
		{
		e.printStackTrace(); throw e; //EXCEPTION
		}
        return attachment;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeGroup getAttributeGroup()
        throws Exception
    {
        AttributeGroup group = null;
        try
        {
            String attGroupId = getIntakeTool()
                .get("AttributeGroup", IntakeTool.DEFAULT_KEY)
                .get("AttributeGroupId").toString();
            if (attGroupId == null || attGroupId.length() == 0)
            {
                group = new AttributeGroup();
            }
            else
            {
                group = AttributeGroupManager.getInstance(new NumberKey(attGroupId), false);
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return group;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public AttributeValue getNewAttributeValue(Attribute attribute, Issue issue)
        throws Exception
    {

        return AttributeValue.getNewInstance(attribute.getAttributeId(),issue);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public RModuleAttribute getRModuleAttribute()
        throws Exception
    {
        RModuleAttribute rma = null;
        try
        {
            ComboKey rModAttId = (ComboKey)getIntakeTool()
                .get("RModuleAttribute", IntakeTool.DEFAULT_KEY)
                .get("Id").getValue();
            if (rModAttId == null)
            {
                Integer attId = (Integer)getIntakeTool()
                    .get("Attribute", IntakeTool.DEFAULT_KEY)
                    .get("Id").getValue();
                Module currentModule = getCurrentModule();
                if (attId != null && currentModule != null)
                {
                    SimpleKey[] nka = {
                        SimpleKey.keyFor(attId),
                        SimpleKey.keyFor(currentModule.getModuleId())
                    };
                    rma = RModuleAttributeManager
                        .getInstance(new ComboKey(nka), false);
                }
                else
                {
                    rma = new RModuleAttribute();
                }
            }
            else
            {
                rma = RModuleAttributeManager.getInstance(rModAttId, false);
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return rma;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Issue getReportingIssue()
        throws Exception
    {
        if (reportingIssue == null)
        {
            String key = data.getParameters()
                .getString(ScarabConstants.REPORTING_ISSUE);

            if (key == null)
            {
                getNewReportingIssue();
            }
            else
            {
                reportingIssue = ((ScarabUser)data.getUser())
                    .getReportingIssue(key);

                // if reportingIssue is still null, the parameter must have
                // been stale, just get a new issue
                if (reportingIssue == null)
                {
                    getNewReportingIssue();
                }
            }
        }
        return reportingIssue;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private void getNewReportingIssue()
        throws Exception
    {
        IssueType currentIssueType = getCurrentIssueType();
        if (currentIssueType != null)
        {
            Module currentModule = getCurrentModule();
            if(currentModule != null)
            {
                reportingIssue = currentModule.getNewIssue(currentIssueType);
                String key = ((ScarabUser)data.getUser())
                    .setReportingIssue(reportingIssue);
                data.getParameters().add(ScarabConstants.REPORTING_ISSUE, key);
            }
        }
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Issue getIssue()
        throws Exception
    {
        if (issue == null)
        {
            String issueId = null;
            Group issueGroup = getIntakeTool()
                .get("Issue", IntakeTool.DEFAULT_KEY, false);
            if (issueGroup != null)
            {
                issueId =  issueGroup.get("Id").toString();
            }
            else
            {
                issueId = data.getParameters().getString("id");
            }
            if (issueId != null && issueId.length() > 0)
            {
                issue = getIssue(issueId);
            }
        }
        return issue;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getIssues()
        throws Exception
    {
        List issues = null;

        Group issueGroup = getIntakeTool()
            .get("Issue", IntakeTool.DEFAULT_KEY, false);
        if (issueGroup != null)
        {
            Long[] issueIds =  (Long []) issueGroup.get("Ids").getValue();
            if (issueIds != null)
            {
                issues = getIssues(Arrays.asList(issueIds));
            }
        }
        else
        {
            String[] paramIssueIds = data.getParameters().getStrings("issue_ids");
            if (paramIssueIds != null)
            {
                issues = getIssues(Arrays.asList(paramIssueIds));
            }
        }
        if (issues == null)
        {
            issues = Collections.EMPTY_LIST;
        }
        return issues;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getIssues(List issueIds)
        throws Exception
    {
        List issues = null;
        StringBuffer invalidIds = null;
        if (issueIds == null || issueIds.isEmpty())
        {
            issues = Collections.EMPTY_LIST;
        }
        else
        {
            if (issueIds.get(0) instanceof String)
            {
                issues = new ArrayList(issueIds.size());
                Iterator i = issueIds.iterator();
                while (i.hasNext())
                {
                    String id = (String)i.next();
                    Issue issue = getIssue(id);
                    if (issue == null)
                    {
                        if (invalidIds == null)
                        {
                            invalidIds = new StringBuffer(id);
                        }
                        else
                        {
                            invalidIds.append(' ').append(id);
                        }
                    }
                    else
                    {
                        issues.add(issue);
                    }
                }
                if (invalidIds != null)
                {
                    setAlertMessage(getLocalizationTool()
                        .format("SomeIssueIdsNotValid", invalidIds.toString()));
                }
            }
            else if (issueIds.get(0) instanceof Long)
            {
                issues = new ArrayList(issueIds.size());
                Iterator i = issueIds.iterator();
                while (i.hasNext())
                {
                    Issue issue = IssueManager.getInstance((Long)i.next());
                    if (issue == null)
                    {
                        setAlertMessage(L10NKeySet.SomeIssuePKsNotValid);
                    }
                    else
                    {
                        issues.add(issue);
                    }
                }
            }
            else
            {
                throw new IllegalArgumentException(
                    "issue ids must be Strings or Longs, not " +
                    issueIds.get(0).getClass().getName()); //EXCEPTION
            }
        }
        return issues;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getScopes()
        throws Exception
    {
        return ScopePeer.getAllScopes();
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getFrequencies()
        throws Exception
    {
        return FrequencyPeer.getFrequencies();
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Intake getConditionalIntake(String parameter)
        throws Exception
    {
        Intake intake = null;
        String param = data.getParameters().getString(parameter);
        if (param == null)
        {
            intake = getIntakeTool();
        }
        else
        {
            StringValueParser parser = ScarabUtil.parseURL(param);
            intake = new Intake();
            intake.init(parser);
        }

        return intake;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private IssueSearch getPopulatedSearch(String queryString)
        throws Exception
    {
        IssueSearch search = getNewSearch();
        Query theQuery = this.getQuery();

        search.setLocale(getLocalizationTool().getPrimaryLocale());
        search.setIssueListAttributeColumns(getRModuleUserAttributes(theQuery));
        search.setLocalizationTool(getLocalizationTool());

        StringValueParser parser = ScarabUtil.parseURL(queryString);

        String[] userList = parser.getStrings("user_list");
        boolean searchInAllAttributes = parser.getBoolean("searchallattributes",false);
        if (userList != null && userList.length > 0)
        {
            for (int i = 0; i < userList.length; i++)
            {
                String userId = userList[i];
                String[] attrIds = parser.getStrings("user_attr_" + userId);
                if (attrIds != null)
                {
                    for (int j = 0; j < attrIds.length; j++)
                    {
                        search.addUserSearch(userId, attrIds[j]);
                    }
                }
            }
        }

        Intake intake = new Intake();
        intake.init(parser);
        Group searchGroup = intake.get("SearchIssue", search.getQueryKey());

        boolean datesValid = true;
        Field minCreationDate = searchGroup.get("MinCreationDate");
        if (minCreationDate!= null && minCreationDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, minCreationDate);
        }

        Field maxCreationDate = searchGroup.get("MaxCreationDate");
        if (maxCreationDate != null && maxCreationDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, maxCreationDate);
        }

        Field minChangeDate = searchGroup.get("MinChangeDate");
        if (minChangeDate != null && minChangeDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, minChangeDate);
        }

        Field maxChangeDate = searchGroup.get("MaxChangeDate");
        if (maxChangeDate != null && maxChangeDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, maxChangeDate);
        }

        Field stateChangeFromDate = searchGroup.get("StateChangeFromDate");
        if (stateChangeFromDate != null
            && stateChangeFromDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, stateChangeFromDate);
        }

        Field stateChangeToDate = searchGroup.get("StateChangeToDate");
        if (stateChangeToDate != null
            && stateChangeToDate.toString().length() > 0)
        {
        	datesValid &= validateDateFormat(search, stateChangeToDate);
        }

        if (!datesValid)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.DateFormatPrompt,L10NKeySet.ShortDateDisplay);
            setAlertMessage(msg);
            return null;
        }

        searchGroup.setProperties(search);

        // Set attribute values to search on
        Map avMap = search.getAttributeValuesMap(!searchInAllAttributes);

        for(Iterator i = avMap.values().iterator();i.hasNext();)
        {
            AttributeValue aval = (AttributeValue)i.next();

            Group group = intake.get("AttributeValue", aval.getQueryKey());

            if (group!=null)
            {
                group.setProperties(aval);
            }

            if(aval instanceof DateAttribute)
            {
                String auxDate = parser.getString("attv__" + aval.getAttributeId().intValue() + "val_aux");

                if (auxDate != null)
                {
                	AttributeValue auxAval = AttributeValue.getNewInstance(aval.getAttribute(), aval.getIssue());
                	auxAval.setValue(auxDate);
                	aval.setChainedValue(auxAval);
                }
            }
        }

        String sortColumn = data.getParameters().getString("sortColumn");
        if(isValidIssueSearchSortColumn(sortColumn))
        {
            search.setSortAttributeId( Integer.valueOf(sortColumn) );
        }
        search.setSortInternalAttribute(data.getParameters().getString("sortInternal"));
        search.setSortPolarity(data.getParameters().getString("sortPolarity"));

        return search;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueSearch getNewSearch() throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        MITList mitList = user.getCurrentMITList();
        IssueSearch search = IssueSearchFactory.INSTANCE.getInstance(mitList, user);
        return search;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueSearch getPopulatedSearch()
        throws Exception
    {
        String currentQueryString = ((ScarabUser)data.getUser()).getMostRecentQuery();
        return getPopulatedSearch(currentQueryString);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private List getUnprotectedCurrentSearchResults()
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();

		// [HD] Very experimental: The following code allows to create a shortLink
		// to a public or private query similar to what has been implemented
		// as shortLink for Issues. The URL-syntax is:
		//
        // <scarabHost>/scarab/issues/query/<queryId>
        // 
        // The queryId should be sufficient to setup the full query.
        // But i have seen a problem, when the user has only limitted
        // module read permissions. In that case the LoginValve
        // forces a login before the query can be perfromed.
        // Workaround: Also add the moduleId to the URL:
        //
        // <scarabHost>/scarab/issues/query/<queryId>/curmodule/<moduleId>
        // 
        // The current solution always uses the default MITList, hence it will
        // not take care of user customized resultsets. 
        // I am not sure, where to place this code and how to actually
        // control the search-Subsystem so that it will perfrom the correct
        // search. Any help and advice for a better solution is heavily welcome!!!
		
        String currentQueryString = user.getMostRecentQuery();
        String sortColumn = data.getParameters().getString("sortColumn");
        String sortInternal=data.getParameters().getString("sortInternal");
        String sortPolarity = data.getParameters().getString("sortPolarity");
        String currentQueryAddition = "" + sortColumn + sortInternal + sortPolarity;
        String cachedQueryAddition = (String)data.getUser().getTemp("queryAddition");

        List queryResult = (List)data.getUser().getTemp("queryResult");

        if (cachedQueryAddition==null || !cachedQueryAddition.equals(currentQueryAddition) || queryResult==null)
        {
            // currentQueryString gets lost if the session timed out. an empty search result is returned then.
            queryResult = null != currentQueryString
                    ? getSearchResults(currentQueryString)
                    : Collections.emptyList();

            data.getUser().setTemp("queryAddition", currentQueryAddition );
            data.getUser().setTemp("queryResult", queryResult);
        }

        return queryResult;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private List getSearchResults(String queryString)
        throws Exception
    {
        IssueSearch search = getPopulatedSearch(queryString);

        if(null != search)
        {
            return search.getQueryResults();	
        }

        return new ArrayList(); //why not Collections.EMPTY_LIST ?
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String convertPath(String path)
        throws Exception
    {
            return path.replace('/',',');
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getAllIssueTemplates(IssueType issueType)
        throws Exception
    {
        List result;
        if(issueType == null)
        {
            Log.get().warn("Can not retrieve IssueTemplates for issueType NULL. Return empty List.");
            result = Collections.EMPTY_LIST;
        }
        else
        {
            ParameterParser params = data.getParameters();
            String sortColumn = params.getString("sortColumn", "name");
            String sortPolarity = params.getString("sortPolarity", "asc");
            result = IssueTemplateInfoPeer.getTemplates(getCurrentModule(),
               issueType, (ScarabUser)data.getUser(),
               sortColumn, sortPolarity, IssueTemplateInfoPeer.TYPE_ALL);
        }
        return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getPrivateTemplates(IssueType issueType)
        throws Exception
    {
        return IssueTemplateInfoPeer.getTemplates(getCurrentModule(),
               issueType, (ScarabUser)data.getUser(),
               "name", "asc", IssueTemplateInfoPeer.TYPE_PRIVATE);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getGlobalTemplates(IssueType issueType)
        throws Exception
    {
        return IssueTemplateInfoPeer.getTemplates(getCurrentModule(),
               issueType, (ScarabUser)data.getUser(),
               "name", "asc", IssueTemplateInfoPeer.TYPE_GLOBAL);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getAllQueries()
        throws Exception
    {
        String sortColumn = data.getParameters().getString("sortColumn");
        String sortPolarity = data.getParameters().getString("sortPolarity");
        if (sortColumn == null)
        {
            sortColumn = "avail";
        }
        if (sortPolarity == null)
        {
            sortPolarity = "desc";
        }
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               sortColumn, sortPolarity, IssueTemplateInfoPeer.TYPE_ALL);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getPrivateQueries()
        throws Exception
    {
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               "name", "asc", QueryPeer.TYPE_PRIVATE);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getUserQueries()
        throws Exception
    {
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               "name", "asc", QueryPeer.TYPE_ALL_USER);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getGlobalQueries()
        throws Exception
    {
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               "name", "asc", QueryPeer.TYPE_GLOBAL);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getGlobalQueries(Module module)
        throws Exception
    {
        return QueryPeer.getQueries(module,
                null, (ScarabUser)data.getUser(),
                "name", "asc", QueryPeer.TYPE_GLOBAL);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getUserAllQueries()
        throws Exception
    {
        return QueryPeer.getQueries(getCurrentModule(),
               null, (ScarabUser)data.getUser(),
               "name", "asc", QueryPeer.TYPE_ALL_USER);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Query getDefaultQuery() throws Exception
    {
        Module currentModule   = getCurrentModule();
        ScarabUser currentUser = getCurrentUser();
        Integer currentUserId  = (currentUser==null)? null:currentUser.getUserId();
        return getDefaultQuery(currentModule, currentUserId);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Query getDefaultQuery(Module module) throws Exception
    {
        Integer ownerId = (module != null) ? module.getOwnerId():null;
        return getDefaultQuery(module, ownerId);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Query getDefaultQuery(Module module, Integer userId) throws Exception
    {
        return QueryPeer.getDefaultQuery(module, userId);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ReportBridge getReport()
        throws Exception
    {
        if (reportGenerator == null)
       {
            String key = data.getParameters()
                .getString(ScarabConstants.CURRENT_REPORT);
            ParameterParser parameters = data.getParameters();
            String id = parameters.getString("report_id");
            if (id == null || id.length() == 0)
            {
                ScarabUser user = (ScarabUser)data.getUser();
                MITList mitlist = user.getCurrentMITList();
                if (key == null)
                {
                    reportGenerator = getNewReport(mitlist);
                }
                else
                {
                    reportGenerator = user.getCurrentReport(key);

                    // if reportingIssue is still null, the parameter must have
                    // been stale, just get a new report
                    if (reportGenerator == null &&
                        mitlist != null && !mitlist.isEmpty())
                    {
                        reportGenerator = getNewReport(mitlist);
                    }
                }
            }
            else
            {
                reportGenerator = new ReportBridge(
                    ReportManager.getInstance(new NumberKey(id), false));
                key = ((ScarabUser)data.getUser())
                    .setCurrentReport(reportGenerator);
                data.getParameters()
                    .remove(ScarabConstants.CURRENT_REPORT);
                data.getParameters()
                    .add(ScarabConstants.CURRENT_REPORT, key);
            }
        }

        return reportGenerator;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private ReportBridge getNewReport(MITList mitList)
        throws Exception
    {
        if (mitList == null)
        {
            throw new IllegalArgumentException(
                "Cannot create a new report without any issue types."); //EXCEPTION
        }

        ScarabUser user = (ScarabUser)data.getUser();
        org.tigris.scarab.om.Report om  = new org.tigris.scarab.om.Report();
        ReportBridge report = new ReportBridge(om);
        report.setGeneratedBy(user);
        report.setMITList(mitList);

        String key = ((ScarabUser)data.getUser()).setCurrentReport(report);
        data.getParameters().add(ScarabConstants.CURRENT_REPORT, key);

        return report;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ScarabPaginatedList getUserSearchResults(MITList mitList,
                                                    int pageNum,
                                                    int resultsPerPage,
                                                    String sortColumn,
                                                    String sortPolarity,
                                                    boolean includeCommitters,
                                                    boolean confirmedOnly)
        throws Exception
    {
        return userFilteredSearchResults(mitList, pageNum, resultsPerPage,
                                         sortColumn, sortPolarity, "", "",
                                         includeCommitters, confirmedOnly);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ScarabPaginatedList getUserFilteredSearchResults(MITList mitList,
        int pageNum, int resultsPerPage,  String sortColumn,
        String sortPolarity, boolean includeCommitters, boolean confirmedOnly)
        throws Exception
    {
        String searchString = data.getParameters()
               .getString("searchString");
        String searchField = data.getParameters()
               .getString("searchField");

        if (searchField == null)
        {
            setInfoMessage(L10NKeySet.SearchFieldPrompt);
            return null ;
        }

        return userFilteredSearchResults(mitList, pageNum, resultsPerPage,
                                         sortColumn, sortPolarity,
                                         searchString, searchField, includeCommitters, confirmedOnly);

    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private ScarabPaginatedList userFilteredSearchResults(MITList mitList,
                                                          int pageNum,
                                                          int resultsPerPage,
                                                          String sortColumn,
                                                          String sortPolarity,
                                                          String searchString,
                                                          String searchField,
                                                          boolean includeCommitters, boolean confirmedOnly)
        throws Exception
    {
        ScarabPaginatedList list = null;
        String name = null;
        String userName = null;

        if ("FullName".equalsIgnoreCase(searchField))
        {
            name = searchString;
        }
        else if ("UserName".equalsIgnoreCase(searchField))
        {
            userName = searchString;
        }

        try
        {
            list = getCurrentModule().getUsers(name, userName, mitList,
                                               pageNum, resultsPerPage,
                                               sortColumn, sortPolarity,
                                               includeCommitters, confirmedOnly);
        }
        catch (Exception e)
        {
            Log.get().error("Problem getting user list", e);
            list = new ScarabPaginatedList();
        }

        // These are object members are used by GlobalMacros.vm via
        // the bean interface.  Leave them here until all users of the
        // paginate macro can be updated.
        this.nbrPages = list.getNumberOfPages();
        this.nextPage = list.getNextPageNumber();
        this.prevPage = list.getPrevPageNumber();

        return list;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getAttributeSearchResults()  throws Exception
    {
        String searchString = data.getParameters()
               .getString("searchString");
        String searchField = data.getParameters()
               .getString("searchField");
        if (searchField == null)
        {
            setInfoMessage(L10NKeySet.SearchFieldPrompt);
            return null ;
        }

        String name = null;
        String description = null;
        if (searchField.equals("Name") || searchField.equals("Any"))
        {
            name = searchString;
        }
        if (searchField.equals("Description") || searchField.equals("Any"))
        {
            description = searchString;
        }

        return sortAttributes(AttributePeer
            .getFilteredAttributes(name, description, searchField));
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List sortUsers(List userList)  throws Exception
    {
        return ScarabUserTool.sortUsers(userList, data);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List sortAttributes(List attList)  throws Exception
    {
        final String sortColumn = data.getParameters().getString("sortColumn");
        final String sortPolarity = data.getParameters().getString("sortPolarity");
        final int polarity = ("desc".equals(sortPolarity)) ? -1 : 1;
        Comparator c = new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                int i = 0;
                if (sortColumn != null && sortColumn.equals("name"))
                {
                    i =  polarity * ((Attribute)o1).getName()
                         .compareTo(((Attribute)o2).getName());
                }
                else
                {
                    i =  polarity * ((Attribute)o1).getDescription()
                         .compareTo(((Attribute)o2).getDescription());
                }
                return i;
             }
        };
        Collections.sort(attList, c);
        return attList;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public void resetAssociatedUsers() throws Exception
    {
        HashMap assoUsers = new HashMap();
        List issueList = getIssues();
        if (issueList != null)
        {
            for (int i=0; i<issueList.size(); i++)
            {
                Issue issue = (Issue)issueList.get(i);
                assoUsers.put(issue.getIssueId(), issue.getAssociatedUsers());
            }
            ((ScarabUser)data.getUser()).setAssociatedUsersMap(assoUsers);
        }
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public void resetSelectedUsers() throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        user.setSelectedUsersMap(null);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ScarabPaginatedList getPaginatedGlobalUsersList(int pageNum, int resultsPerPage,
    		String searchField, String searchCriteria, String sortColumn, String sortPolarity)
    	throws Exception
    {
    	ScarabPaginatedList paginated;
    	Criteria crit = new Criteria();
    	Criteria critCount = new Criteria();
    	crit.setOffset((pageNum-1)*resultsPerPage);
    	crit.setLimit(resultsPerPage);
    	crit.add(ScarabUserImplPeer.USER_ID, (Object)(ScarabUserImplPeer.USER_ID+" IS NOT NULL"), Criteria.CUSTOM);
        crit.addNotIn(ScarabUserImplPeer.CONFIRM_VALUE,new Object[]{"DELETED"} );
        critCount.addNotIn(ScarabUserImplPeer.CONFIRM_VALUE,new Object[]{"DELETED"} );

        if (searchField != null)
        {
            if (searchField.equals("LOGIN_NAME"))
                searchField = ScarabUserImplPeer.LOGIN_NAME;
            else if (searchField.equals("LAST_NAME"))
                searchField = ScarabUserImplPeer.LAST_NAME;
            else if (searchField.equals("FIRST_NAME"))
                searchField = ScarabUserImplPeer.FIRST_NAME;
            else if (searchField.equals("EMAIL"))
                searchField = ScarabUserImplPeer.EMAIL;
            crit.add(searchField, (Object)("%" + searchCriteria + "%"), Criteria.LIKE);
            critCount.add(searchField, (Object)("%" + searchCriteria + "%"), Criteria.LIKE);

            String col = ScarabUserImplPeer.FIRST_NAME;
            if (sortColumn.equals("LOGIN_NAME"))
                col = ScarabUserImplPeer.LOGIN_NAME;
            else if (sortColumn.equals("LAST_NAME"))
                col = ScarabUserImplPeer.LAST_NAME;
            else if (sortColumn.equals("FIRST_NAME"))
                col = ScarabUserImplPeer.FIRST_NAME;
            else if (sortColumn.equals("EMAIL"))
                col = ScarabUserImplPeer.EMAIL;
            if (sortPolarity.equalsIgnoreCase("asc"))
            {
                crit.addAscendingOrderByColumn(col);
            }
            else
            {
                crit.addDescendingOrderByColumn(col);
            }
        }

    	critCount.add(ScarabUserImplPeer.USER_ID, (Object)(ScarabUserImplPeer.USER_ID+" IS NOT NULL"), Criteria.CUSTOM);
    	List result = ScarabUserImplPeer.doSelect(crit);
    	critCount.addSelectColumn("COUNT(*)");
    	int totalResultSize = ScarabUserImplPeer.getUsersCount(critCount);
        if (totalResultSize > 0 && resultsPerPage > 0)
        {

            paginated = new ScarabPaginatedList(result, totalResultSize,
                                                pageNum,
                                                resultsPerPage);
        }
        else
        {
            paginated = new ScarabPaginatedList();
        }

    return paginated;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public MITList getMITList(List issues)
    throws Exception
    {
        ScarabUser user = getCurrentUser();
        return MITListManager.getInstanceFromIssueList(issues, user);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getUserAttributes(List issues, boolean activeOnly)
        throws Exception
    {
        List attributes = null;
        if (issues == null || issues.isEmpty())
        {
            attributes = Collections.EMPTY_LIST;
            Log.get().warn("ScarabRequestTool.getUserAttributes issue list was"
                     + (issues == null ? " null" : " empty")) ;
        }
        else
        {
            attributes = getMITList(issues).getCommonUserAttributes(activeOnly);
        }

        return attributes;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Object getLastEnteredIssueTypeOrTemplate()
        throws Exception
    {
        Object result = null;
        IssueType issueType = getCurrentIssueType();
        ScarabUser user = (ScarabUser)data.getUser();
        String templateId = data.getParameters().getString("templateId");
        if (templateId != null && templateId.trim().length() > 0)
        {
            Issue template = getIssueTemplate(templateId);
            issueType = template.getIssueType().getIssueTypeForTemplateType();
            user.setLastEnteredTemplate(template);
            result = template;
        }

        if (result == null && issueType != null)
        {
            result = issueType;
            user.setLastEnteredIssueType(issueType);
        }

        if (result == null)
        {
            result = user.lastEnteredIssueTypeOrTemplate();
            if (result != null)
            {
                if (result instanceof Issue)
                {
                    issueType = ((Issue)result).getIssueType()
                        .getIssueTypeForTemplateType();
                }
                else if (result instanceof IssueType)
                {
                    issueType = (IssueType)result;
                }
                else
                {
                    Log.get().warn("An object of unexpected class was saved as"
                        + " the last entered issue type or template: " +
                        result.getClass().getName());
                    result = null;
                }

            }
        }

        // finally if we have a value, check that it is active
        if (issueType != null)
        {
            RModuleIssueType rmit =
                getCurrentModule().getRModuleIssueType(issueType);
            if (rmit == null || !rmit.getActive())
            {
                result = null;
            }
        }

        return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getSortedAttributeOptionsForRMIT(RModuleIssueType rmit) throws Exception
    {
    	List attributes = rmit.getIssueType().getActiveAttributes(rmit.getModule());
    	List result = new ArrayList();
    	for (Iterator it = attributes.iterator(); it.hasNext(); )
    	{
    		Attribute attr = (Attribute)it.next();
    		if (attr.getAttributeType().getAttributeClass().getName().equals("select-one"))
    			result.addAll(attr.getAttributeOptions());
    	}
    	return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public RModuleIssueType getRModuleIssueType(Integer moduleId, Integer issueTypeId) throws Exception
    {
        return RModuleIssueTypePeer.retrieveByPK(moduleId, issueTypeId);
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public ScarabUser getUserByUsername(String username) throws Exception
    {
        return ScarabUserManager.getInstance(username);
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Permission getPermissionByName(String name) throws Exception
    {
        Permission permission = null;
        permission = TurbineSecurity.getPermission(name);
        
        return permission;
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Role getRoleByName(String name) throws Exception
    {
        Role role = null;
        role = TurbineSecurity.getRole(name);
        
        return role;
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Group[] getGroups() throws Exception
    {
        Group[] allModules = TurbineSecurity.getAllGroups().getGroupsArray();
        return allModules;
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getActiveScarabModules() throws Exception
    {
        Group[] allModules = TurbineSecurity.getAllGroups().getGroupsArray();
        List result = new LinkedList();
        for(int index=0; index < allModules.length; index++)
        {
            if(allModules[index] instanceof ScarabModule)
            {
                ScarabModule module = (ScarabModule)allModules[index];
                if(!module.getDeleted())
                {
                    result.add(module);
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getNonMemberGroups(ScarabUser user) throws Exception
    {
        AccessControlList acl = user.getACL();
        Group[] groups = TurbineSecurity.getAllGroups().getGroupsArray();
        List nonmemberGroups = new LinkedList();
        for (int i=0; i<groups.length; i++) 
        {
            Module module = (Module)groups[i];
            if (!module.isGlobalModule() && !module.getDeleted()) 
            {
                RoleSet roleSet = acl.getRoles(groups[i]);
                if (roleSet == null || roleSet.size() == 0) 
                {
                    boolean hasRole = false;
                    // need to check for already requested roles
                    Role[] roles = 
                        TurbineSecurity.getAllRoles().getRolesArray();
                    for (int j=0; j<roles.length; j++) 
                    {
                        if (hasRequestedRole(user, roles[j], groups[i])) 
                        {
                            hasRole = true;
                            break;
                        }
                    }
                    if (!hasRole) 
                    {
                        nonmemberGroups.add(groups[i]);   
                    }                    
                }   
            }
        }
        return nonmemberGroups;
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Permission[] getPermissions() throws Exception
    {
        return (TurbineSecurity.getAllPermissions().getPermissionsArray());
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getPermissionsAsStrings() throws Exception
    {
        Permission[] allPerms = this.getPermissions();
        List list = new ArrayList(allPerms.length);
        for (int i=0; i<allPerms.length;i++)
        {
            list.add(allPerms[i].getName());
        }
        return list;
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public Role[] getRoles() throws Exception
    {
        return TurbineSecurity.getAllRoles().getRolesArray();
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getNonRootRoles() throws Exception
    {
        List nonRootRoles = new LinkedList();
        Role[] roles = TurbineSecurity.getAllRoles().getRolesArray();
        for (int i=0; i<roles.length; i++) 
        {
            Role role = roles[i];
            if (!role.getName().equals("Root")) 
            {
                nonRootRoles.add(role);
            }
        }
        return nonRootRoles;
    }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static List sortUsers(List userList,  RunData data)  throws Exception
    {
        final String sortColumn = data.getParameters().getString("sortColumn");
        final String sortPolarity = data.getParameters().getString("sortPolarity");
        final int polarity = ("desc".equals(sortPolarity)) ? -1 : 1;
        Comparator c = new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                int i = 0;
                if ("username".equals(sortColumn))
                {
                    i =  polarity * ((ScarabUser)o1).getUserName()
                         .compareTo(((ScarabUser)o2).getUserName());
                }
                else
                {
                    i =  polarity * ((ScarabUser)o1).getName()
                         .compareTo(((ScarabUser)o2).getName());
                }
                return i;
             }
        };
        Collections.sort(userList, c);
        return userList;
    }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
private String getInternal(String key) 
        throws Exception
    {
        String value = null;
        
        // Try with all defined "Browser"-Locales ordered by relevance
        Iterator iter = locales.iterator();
        while (value == null && iter.hasNext())
        {
            Locale locale = (Locale) iter.next();
            value = resolveKey(key, locale);
        }
        return value;
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllAttributes()
        throws Exception
    {
        return AttributePeer.getAttributes();
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAttributes(String attributeType)
        throws Exception
    {
        return AttributePeer.getAttributes(attributeType, false);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllAttributes(String attributeType, boolean includeDeleted,
                                 String sortColumn, String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes(attributeType, includeDeleted, 
                                           sortColumn, sortPolarity);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllAttributes(String sortColumn, String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes(sortColumn, sortPolarity);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getUserAttributes()
        throws Exception
    {
        return AttributePeer.getAttributes("user");
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getUserAttributes(String sortColumn, String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes("user", false, sortColumn, sortPolarity);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getUserAttributes(boolean includeDeleted, String sortColumn, 
                                  String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes("user", includeDeleted, sortColumn, sortPolarity);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAttributes(String attributeType, boolean includeDeleted, 
                              String sortColumn, String sortPolarity)
        throws Exception
    {
        return AttributePeer.getAttributes(attributeType, includeDeleted,
                                           sortColumn, sortPolarity);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllIssueTypes()
        throws Exception
    {
        return IssueTypePeer.getAllIssueTypes(false, "name", "asc");
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllIssueTypes(boolean deleted)
        throws Exception
    {
        return IssueTypePeer.getAllIssueTypes(deleted, "name", "asc");
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getAllIssueTypes(boolean deleted, String sortColumn, 
                                 String sortPolarity)
        throws Exception
    {
        return IssueTypePeer.getAllIssueTypes(deleted, sortColumn, sortPolarity);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getSearchUsers(String searchField, String searchCriteria)
        throws Exception
    {
        return (getSearchUsers(searchField, searchCriteria, null, null));
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getSearchUsers(String searchField, String searchCriteria, 
                               String orderByField, String ascOrDesc)
        throws Exception
    {
        ArrayList userSearchList = new ArrayList();
        String lSearchField = "";
        String lOrderByField = "";
        
        Criteria criteria = new Criteria();
        
        // add the input from the user
        if (searchCriteria != null && searchCriteria.length() > 0)
        {
            if (searchField.equals("FIRST_NAME"))
            {
                lSearchField = ScarabUser.FIRST_NAME;
            }
            else if (searchField.equals("LAST_NAME"))
            {
                lSearchField = ScarabUser.LAST_NAME;
            }
            else if (searchField.equals("LOGIN_NAME"))
            {
                lSearchField = ScarabUser.USERNAME;
            }
            else
            {
                lSearchField = ScarabUser.EMAIL;
            }
            
            // FIXME: Probably shouldn't be using ScarabUserPeerImpl here
            // What should we do to get the right table name?
            lSearchField = ScarabUserImplPeer.getTableName() + '.' + lSearchField;
            
            criteria = criteria.add(lSearchField,
                                        (Object)('%' + searchCriteria.trim() + '%'),Criteria.LIKE);
        }
        
        // sort the results
        if (orderByField != null && orderByField.length() > 0)
        {
            if (orderByField.equals("FIRST_NAME"))
            {
                lOrderByField = ScarabUser.FIRST_NAME;
            }
            else if (orderByField.equals("LAST_NAME"))
            {
                lOrderByField = ScarabUser.LAST_NAME;
            }
            else if (orderByField.equals("LOGIN_NAME"))
            {
                lOrderByField = ScarabUser.USERNAME;
            }
            else
            {
                lOrderByField = ScarabUser.EMAIL;
            }
            
            // FIXME: Probably shouldn't be using ScarabUserPeerImpl here
            // What should we do to get the right table name?
            lOrderByField = ScarabUserImplPeer.getTableName() + '.' + lOrderByField;
            
            if (ascOrDesc != null && ascOrDesc.equalsIgnoreCase("DESC"))
            {
                criteria = criteria.addDescendingOrderByColumn(lOrderByField);
            } 
            else
            {
                criteria = criteria.addAscendingOrderByColumn(lOrderByField);
            }
        }
        
        User[] tempUsers = TurbineSecurity.getUsers(criteria);  
        for (int i=0; i < tempUsers.length; i++)
        {
            userSearchList.add(i, tempUsers[i]);
        }
        return (userSearchList);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public SkipFiltering textToHTML(String text,
                                    ScarabLink link,
                                    Module currentModule) throws Exception
    {
        String renderEngine = currentModule.getCommentRenderingEngine();
        String txt;
        if(renderEngine.equals("radeox"))
        {
            txt = engine.render(text, context);
        }
        else if(renderEngine.equals("html")){
        	 txt = text;
        }
        else
        {
            txt = "<pre>" + 
                  perlUtil.substitute(REGEX_URL,
                  perlUtil.substitute(REGEX_MAILTO,
                  ReferenceInsertionFilter.filter(text)))
                  + "</pre>";
        }
        
        return new SimpleSkipFiltering(ScarabUtil.linkifyText(txt, link, currentModule));
    }
            
// in java/org/tigris/scarab/om/MITList.java
private List getMatchingRMOs(List rmos) throws TorqueException, Exception
    {
        List matchingRMOs = new ArrayList();
        if (rmos != null)
        {
            for (Iterator i = rmos.iterator(); i.hasNext();)
            {
                RModuleOption rmo = (RModuleOption) i.next();
                AttributeOption option = rmo.getAttributeOption();
                if (rmo.getActive() && isCommon(option))
                {
                    matchingRMOs.add(rmo);
                }
            }
        }
        return matchingRMOs;
    }
            
// in java/org/tigris/scarab/om/Activity.java
public String getDescription(ScarabLocalizationTool l10n)
        throws Exception
    {
        return getDisplayName(l10n) + ": " + getNewValue(l10n) + " (" + getOldValue(l10n) + ")";
    }
            
// in java/org/tigris/scarab/om/Activity.java
public String getOldValue(ScarabLocalizationTool l10n) 
    throws Exception
	{
	    return getOldValue(null, l10n);
	}
            
// in java/org/tigris/scarab/om/Activity.java
public String getOldValue(Issue issue, ScarabLocalizationTool l10n) 
        throws Exception
    {
        String value              = null;
        ActivityType activityType = getType();
        String oldValue           = getOldValue();
        
        if(   ActivityType.DEPENDENCY_DELETED.equals(activityType)
           || ActivityType.DEPENDENCY_CHANGED.equals(activityType))
        {
        	 value = getDepend().getIssueRelatedByObserverId().getUniqueId()
             + " < " + l10n.get(DependTypeManager.getManager().getL10nKey(oldValue)) + " > "
              + " " + getDepend().getIssueRelatedByObservedId().getUniqueId();       
        } 
        else if( ActivityType.ATTACHMENT_REMOVED.equals(activityType))
        {
             value = getAttachment().getFileName();
        } 
        else if( ActivityType.URL_DELETED.equals(activityType))
        {
             value = getAttachment().getData();
        } 
        else if( ActivityType.COMMENT_CHANGED.equals(activityType))
        {
             value = oldValue!=null ? firstChars( oldValue, 50 ) : "";
        } 
        else 
        {
        	//assumption that an attribute was changed
        	if(getAttribute() != null && getAttribute().isDateAttribute())
        	{
         		value = DateAttribute.dateFormat(oldValue!=null ? oldValue : "",  L10NKeySet.ShortDateDisplay.getMessage(l10n));
         	}
         	else
         	{
         		value = oldValue!=null ? oldValue : "";
         	}
        }

        return value;
    }
            
// in java/org/tigris/scarab/om/Activity.java
public String getNewValue(ScarabLocalizationTool l10n) throws Exception{
        return getNewValue(null, l10n);
    }
            
// in java/org/tigris/scarab/om/Activity.java
public String getNewValue(Issue issue, ScarabLocalizationTool l10n)
        throws Exception
    {
        String value = null;
        ActivityType activityType = getType();
        String newValue = getNewValue();
        
        if(   ActivityType.DEPENDENCY_CREATED.equals(activityType)
           || ActivityType.DEPENDENCY_CHANGED.equals(activityType))
        {
            if(newValue == null)
            {
                throw new RuntimeException("Dependency creation/change needs a new value. (Does imply that Dependency deletion is NOT supported?). The Error occured in issue " 
                          + issue.getParents()+ issue.getIdCount() );
            }
        	if(issue != null 
        			&& issue.getIssueId().intValue() != getDepend().getIssueRelatedByObservedId().getIssueId().intValue()
        			&& "blocking".equals(newValue))
        	{
            	value = getDepend().getIssueRelatedByObserverId().getUniqueId()
                + " " + l10n.get("DependsOn") //deprecated, but method is used many times in scarab.
            	+ " " + getDepend().getIssueRelatedByObservedId().getUniqueId(); 
            }
            else
            {
            	value = getDepend().getIssueRelatedByObservedId().getUniqueId()
            	+ " " + ("blocking".equals(newValue) ? l10n.get("PrerequisiteFor") : l10n.get(DependTypeManager.getManager().getL10nKey(newValue)))
                + " " + getDepend().getIssueRelatedByObserverId().getUniqueId();  
            }
        } 
        else if( ActivityType.ATTACHMENT_CREATED.equals(activityType))
        {
            value = getAttachment().getFileName();
        }
        else if(    ActivityType.URL_ADDED.equals(activityType)
                || ActivityType.COMMENT_ADDED.equals(activityType))
        {
            value = getAttachment().getData();
        }
        else if( ActivityType.COMMENT_CHANGED.equals(activityType))
        {
            value = newValue!=null ? firstChars( newValue, 50 ) : "";
        }
        else if( getType().equals(ActivityType.OTHER))
        {
            value = super.getDescription()!=null ? super.getDescription() : "";
        } 
        else 
        {
        	//assumption that an attribute was changed
        	if(getAttribute() != null && getAttribute().isDateAttribute())
        	{
        		value = DateAttribute.dateFormat(newValue!=null ? newValue : "",  L10NKeySet.ShortDateDisplay.getMessage(l10n));
        	}
        	else
        	{
        		value = newValue!=null ? newValue : "";
        	}            
        }
        return value;
    }
            
// in java/org/tigris/scarab/om/Activity.java
public String getDisplayName(ScarabLocalizationTool l10n)
        throws Exception
    {
        String name=null;
        if(this.getAttribute().getAttributeId().intValue()!=0)
        {
            name = getDisplayName();
        } else if(   getType().equals(ActivityType.OTHER))
        {
            name = l10n.get(L10NKeySet.OtherActivity);
        } else if(    getType().equals(ActivityType.ATTACHMENT_CREATED)
                   || getType().equals(ActivityType.ATTACHMENT_REMOVED))
        {
            name = l10n.get(L10NKeySet.Attachment);
        } else if(    getType().equals(ActivityType.DEPENDENCY_CREATED)
                   || getType().equals(ActivityType.DEPENDENCY_CHANGED)
                   || getType().equals(ActivityType.DEPENDENCY_DELETED))
        {
            name = l10n.get(L10NKeySet.Link);
        } else if(    getType().equals(ActivityType.URL_ADDED)
                   || getType().equals(ActivityType.URL_CHANGED)
                   || getType().equals(ActivityType.URL_DESC_CHANGED)
                   || getType().equals(ActivityType.URL_DELETED))
        {
            name = l10n.get(L10NKeySet.URL);
        } else if(    getType().equals(ActivityType.COMMENT_ADDED)
                   || getType().equals(ActivityType.COMMENT_CHANGED))
        {
            name = l10n.get(L10NKeySet.Comment);
        }
        else if(    getType().equals(ActivityType.ISSUE_COPIED)
                || getType().equals(ActivityType.ISSUE_MOVED)
                || getType().equals(ActivityType.ISSUE_CREATED)
                || getType().equals(ActivityType.ISSUE_DELETED))
	     {
	         name = l10n.get(L10NKeySet.IssueId);
	     }
        return name;
    }
            
// in java/org/tigris/scarab/om/Activity.java
public String getDisplayName()
        throws Exception
    {
        RModuleAttribute attr = getIssue().getModule().getRModuleAttribute(this.getAttribute(), this.getIssue().getIssueType());
        if (attr!=null)
            return attr.getDisplayValue();
        else
            return getAttribute().getName();
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser reactivateUserIfDeleted(ScarabUser su) throws Exception
    {
        String username = su.getUserName();
        ScarabUser reactivatedUser=(ScarabUser) TurbineSecurity.getUser(username);
        String cs = reactivatedUser.getConfirmed();
        if(cs.equals(ScarabUser.DELETED))
        {
            reactivatedUser.setConfirmed(su.getConfirmed());
            reactivatedUser.setEmail(su.getEmail());
            String encryptedPassword = TurbineSecurity.encryptPassword(su.getPassword());
            reactivatedUser.setPassword(encryptedPassword);
            reactivatedUser.setFirstName(su.getFirstName());
            reactivatedUser.setLastName(su.getLastName());
            reactivatedUser.save();
            su = reactivatedUser;
            getMethodResult().remove(SCARAB_USER_MANAGER, GET_INSTANCE, username );
        } 
        else
        {
            su = null;
        }
        return su;
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public List getAncestors()
        throws TorqueException, Exception
    {
        ancestors = new ArrayList();
        AttributeOption parent = getParentOption();
        if (!ROOT_ID.equals(parent.getOptionId()))
        {
            addAncestors(parent);
        }
        return ancestors;
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
private void addAncestors(AttributeOption option)
        throws TorqueException, Exception
    {
        if (!ROOT_ID.equals(option.getParent().getOptionId()))
        {
            if (ancestors.contains(option.getParent()))
            {
                throw new TorqueException("Tried to add a recursive parent-child " +
                                    "attribute option relationship."); //EXCEPTION
            }
            else
            { 
                addAncestors(option.getParent());
            }
        }
        ancestors.add(option.getOptionId());
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public ReportBridge getDefaultReport()
        throws Exception
    {     
        ReportBridge defaultReport=(ReportBridge) ModuleManager.getMethodResult()
           .get(this,GET_DEFAULTREPORT);
            
        if(defaultReport==null){
            String reportId = GlobalParameterManager.getString(GlobalParameter.DEFAULT_REPORT,this);
            Report report=reportId.equals("") ? null : 
                ReportManager.getInstance(new NumberKey(reportId));

            if(report!=null && !report.getDeleted())
            {
                defaultReport = new ReportBridge(report);     
                ModuleManager.getMethodResult().put(defaultReport,this,GET_DEFAULTREPORT);
            }
        }
            
        return defaultReport;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void addVote(ScarabUser user)
        throws ScarabException, Exception
    {
        // check to see if the user has voted for this issue
        int previousVotes = 0;
        IssueVote issueVote = null;
        Criteria crit = new Criteria()
            .add(IssueVotePeer.ISSUE_ID, getIssueId())
            .add(IssueVotePeer.USER_ID, user.getUserId());
        List votes = IssueVotePeer.doSelect(crit);
        if (votes != null && votes.size() != 0) 
        {
            issueVote = (IssueVote)votes.get(0);
            previousVotes = issueVote.getVotes();
        }
        else 
        {
            issueVote = new IssueVote();
            issueVote.setIssueId(getIssueId());
            issueVote.setUserId(user.getUserId());
        }

        // check if the module accepts multiple votes
        if (!getModule().allowsMultipleVoting() && previousVotes > 0)
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleVoteForUnallowed,
                                      user.getUserName(), 
                                      getUniqueId());
        }
        
        // save the user's vote
        issueVote.setVotes(previousVotes+1);
        issueVote.save();

        // update the total votes for the issue
        crit = new Criteria()
            .add(AttributeValuePeer.ATTRIBUTE_ID, 
                 AttributePeer.TOTAL_VOTES__PK);
        List voteValues = getAttributeValues(crit);
        TotalVotesAttribute voteValue = null;
        if (voteValues.size() == 0) 
        {
            voteValue = new TotalVotesAttribute();
            voteValue.setIssue(this);
            voteValue.setAttributeId(AttributePeer.TOTAL_VOTES__PK);
        }
        else 
        {
            voteValue = (TotalVotesAttribute)voteValues.get(0);
        }
        // Updating attribute values requires a activitySet
        ActivitySet activitySet = attachActivitySet(null, user, null, 
           ActivitySetTypePeer.RETOTAL_ISSUE_VOTE__PK);
        voteValue.startActivitySet(activitySet);
        voteValue.addVote();
        voteValue.save();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void deleteIssue(ScarabUser user)
        throws Exception, ScarabException
    {        
        if (user.hasPermission(ScarabSecurity.ISSUE__DELETE, this.getModule()))
        {
            ActivitySet activitySet = attachActivitySet(null, user);
            ActivityManager.createDeleteIssueActivity(this, activitySet);
            
            Attachment attachment = new Attachment();
            
            String note = Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "DeletedIssueNote");
            
            attachment.setData(note);
            attachment.setName(note);
            attachment.setTextFields(user, this, Attachment.MODIFICATION__PK);
            attachment.save();         
            
            this.setDeleted(true);
            List dependencies = this.getDependsRelatedByObservedId();
            dependencies.addAll(this.getDependsRelatedByObserverId());
            for (Iterator it = dependencies.iterator(); it.hasNext(); )
            {
                Depend depend = (Depend)it.next();
                if(!depend.getDeleted()){
                	ActivitySet deleteSet = 
                        this.doDeleteDependency(activitySet, depend, user);
                    for (Iterator act = deleteSet.getActivityList().iterator(); act.hasNext(); )
                    {
                        activitySet.addActivity((Activity)act.next());
                    }
                }        
            }
            
            activitySet.setAttachment(attachment);
            
            NotificationManagerFactory.getInstance()
            .addActivityNotification(ActivityType.ISSUE_DELETED,
                    activitySet, this, user);
            
            save();
        }
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
private List getActivityList(Issue issue, List activityTypes)
        throws Exception
    {
        List filteredActivities = new ArrayList();
        for(Iterator activities = getActivityList( issue ).iterator(); activities.hasNext();)
        {
            Activity activity = (Activity)activities.next();
            if(activityTypes.contains(ActivityType.getActivityType(activity.getActivityType())))
                filteredActivities.add(activity);
        }
        return filteredActivities;
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
private List getActivityList(Issue issue, ActivityType activityType)
        throws Exception
    {
        ActivityType[] types = {activityType};
        return getActivityList(issue, Arrays.asList(types));  
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public String getCommentForHistory(Issue issue) 
        throws Exception
    {
        String comment = null;
        List comments = getActivityList(issue, ActivityType.COMMENT_ADDED);
        if(comments.size()==1)
            comment=((Activity)comments.get(0)).getAttachment().getData();
        else
            comment=getActivityReason();
        
        return comment;
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public List getActivityListForHistory(Issue issue) 
        throws Exception
    {
        return getActivityList(issue, historyTypeList);  
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public static void confirmUser (String username)
        throws Exception
    {
        User user = ScarabUserManager.getInstance(username);
        user.setConfirmed(User.CONFIRM_DATA);
        TurbineSecurity.saveUser(user);
        ScarabUserManager.getMethodResult().remove( ScarabUserManager.SCARAB_USER_MANAGER, ScarabUserManager.GET_INSTANCE, username );            
    }
            
// in java/org/tigris/scarab/om/ScarabModulePeer.java
public static boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        Criteria criteria = new Criteria();
        criteria.addSelectColumn(MODULE_ID);
        String name = ((Module)group).getRealName();
        criteria.add(MODULE_NAME, name);
        criteria.add(PARENT_ID, ((Module)group).getParentId());
        List results = BasePeer.doSelect(criteria);
        if(results.size() > 1)
        {
            throw new DataBackendException("Multiple groups named '" +
                name + "' exist!"); //EXCEPTION
        }
        return (results.size()==1);
    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private void sendEmail(EmailContext context, Issue issue, ScarabUser user)
            throws Exception
    {
        context.setSubjectTemplate("notification/IssueActivitySubject.vm");
        context.setDefaultTextKey(issue.getDefaultText());
        Set toUsers = new HashSet();
        toUsers.add(user);
        
        String[] fromUser    = getFromUser(issue, context);
        String[] replyToUser = issue.getModule().getSystemEmail();
        
        Email.sendEmail(
                context,
                issue.getModule(),
                fromUser,
                replyToUser,
                toUsers,
                null,
                "notification/IssueActivity.vm");
    }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandlerClient.java
public void testXmlRpc() throws Exception
    {
        XmlRpcClientComponent cli = new DefaultXmlRpcClientComponent();
        Vector v = new Vector();
        v.add("Pacman JVM");            // Module
        v.add("PAC1");                  // IssueID
        v.add("Administrator");         // User
        v.add("Prueba pruebilla");      // Comment
        v.add(new Integer(1));          // DISABLE email sending
        Vector vRdo = (Vector)cli.executeRpc(new URL("http://localhost:12345/simple"), "simple.addComment", v);
        System.out.println("The call was successful: " + (vRdo.size()==1));
        System.out.println("The comment was added: " + vRdo.get(0));
    }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
protected boolean addComment(final Issue issue, final ScarabUser user,
            final String comment, final boolean disableEmails) throws Exception
    {

        log("adding comment to " + issue.getIssueId());
        
        // buffer the comment so we can break it down if MAX_COMMENT_SIZE != 0
        final BufferedReader reader = new BufferedReader(new StringReader(
                comment));
        // The comment Attachments that will be added to the issue.
        // This will only contain one Attachment when MAX_COMMENT_SIZE == 0
        final List comments = new LinkedList();
        final StringBuffer nextComment = new StringBuffer();
        String nextLine = "";
        do
        {
            nextLine = reader.readLine();

            if (nextLine == null || 
                  ( MAX_COMMENT_SIZE > 0 
                      && nextComment.length() + nextLine.length() > MAX_COMMENT_SIZE ) )
            {
                final Attachment attachment = new Attachment();
                attachment.setData(nextComment.toString());
                comments.add(0, attachment); // reverse order the list, it looks better on issue page.
                nextComment.setLength(0);
            }
            if (nextLine != null)
            {
                nextComment.append(nextLine + '\n');
            }

        } while (nextLine != null);

        // actually add the comment Attachments to issue
        synchronized (GlobalParameter.EMAIL_ENABLED)
        {
            // turn off emailing? we need to remember original state anyway...
            final boolean originalEmailState = GlobalParameterManager
                .getBoolean(GlobalParameter.EMAIL_ENABLED); 
            
            if (disableEmails && originalEmailState)
            {
                GlobalParameterManager.setBoolean(GlobalParameter.EMAIL_ENABLED, false);
            }
            for( Iterator it = comments.iterator(); it.hasNext(); )
            {
		Attachment attachment = (Attachment)it.next();
		if( attachment.getData() != null && attachment.getData().length() >0 )
		{
                	issue.addComment(attachment, user);
 	 	}
	    }
            if (disableEmails && originalEmailState)
            {
                GlobalParameterManager.setBoolean(GlobalParameter.EMAIL_ENABLED,
                          originalEmailState);
            }                
        }

        // [TODO] It isn't neccessary to do all of these, which one is the correct one?!?
        ScarabCache.clear();
        IssueManager.getMethodResult().clear();
        ModuleManager.getMethodResult().clear();

        return true;
    }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
protected boolean changeIssueAttributeOption(final Issue issue,
            final ScarabUser user, final Attribute attribute,
            final AttributeOption option, final String description)
            throws Exception
    {

        final AttributeValue status = issue.getAttributeValue(attribute);
        final AttributeValue nyStatus = AttributeValue.getNewInstance(
                attribute, issue);
        nyStatus.setOptionId(option.getOptionId());
        //nyStatus.setActivityDescription(description);
        final Attachment attachment = new Attachment();
        attachment.setData(description);
        attachment.setName("comment");
        final HashMap newAttVals = new HashMap();
        newAttVals.put(status.getAttributeId(), nyStatus);
        final ActivitySet activitySet = issue.setAttributeValues(null,
                newAttVals, attachment, user);
        return true;
    }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
protected Vector findIssuesWithAttributeValue(final ScarabUser user,
            final Attribute attribute, final String value) throws Exception
    {
        final Vector matchingIssueIds = new Vector();
        IssueSearch search = IssueSearchFactory.INSTANCE.getInstance(
               MITListManager.getAllModulesAllIssueTypesList(user), user);
        search.addAttributeValue(attribute, value);
        final List queryresults = search.getQueryResults();

        for(Iterator i=queryresults.iterator();i.hasNext();)
        {
            final QueryResult qr = (QueryResult) i.next();
            matchingIssueIds.add(qr.getUniqueId());
        }
        return matchingIssueIds;
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandlerClient.java
public void testXmlRpc() throws Exception
    {
        XmlRpcClientComponent cli = new DefaultXmlRpcClientComponent();
        Vector v = new Vector();
        Vector o = new Vector();
        v.add("Status");            // Module
        
        o.add("Newer");                  // IssueID
        o.add("Closed");                  // IssueID
        o.add("Killed");                  // IssueID
        o.add("Dunno");                  // IssueID
        v.add(o);
        
        Vector vRdo = (Vector)cli.executeRpc(new URL("http://localhost:12345/dmm"), "dmm.updateAttributeOptions", v);
        System.out.println("The call was successful: " + (vRdo.get(0)));
        System.out.println("The comment was added: " + vRdo.get(1));

        
        v = new Vector();
        v.add("Status");            // Module
        vRdo = (Vector)cli.executeRpc(new URL("http://localhost:12345/dmm"), "dmm.sortAttributeOptions", v);

        System.out.println("The call was successful: " + (vRdo.get(0)));
        System.out.println("The comment was added: " + vRdo.get(1));
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void addAttributeOption(String attribute, String optionName)
            throws Exception {
        // get the relevant entities
        AttributeOption option = getAttributeOption(attribute, optionName);
        Attribute attr = getOptionAttribute(attribute);
        setAttributeOptionDeletedFlag(attr, option, false);
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void removeAttributeOption(String attribute, String optionName)
            throws Exception {
        
        // get the relevant entities
        AttributeOption option = getAttributeOption(attribute, optionName);
        Attribute attr = getOptionAttribute(attribute);

        setAttributeOptionDeletedFlag(attr, option, true);
        option.deleteIssueTypeMappings();
        option.deleteModuleMappings();
       
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private AttributeOption getAttributeOption(String attribute, String option)
            throws Exception {
        // get all options related to this attribute
        Attribute attr = getOptionAttribute(attribute);        
        return AttributeOptionManager.getInstance(attr, option);
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void mapAttributeOptionToAllModuleIssueTypes(String attribute,
            String option) throws Exception {
        Iterator iter;
        AttributeOption ao = getAttributeOption(attribute, option);
        if (ao.getDeleted()) {
            ao.deleteIssueTypeMappings();
            ao.deleteModuleMappings();
        } else {
            // add module mappings
            iter = getModuleAttributes(attribute).iterator();
            while (iter.hasNext()) {
                RModuleAttribute rat = (RModuleAttribute) iter.next();
                IssueType it = rat.getIssueType();
                Module mod = rat.getModule();

                // skip template IssueTypes
                if (!isIssueTypeTemplate(it) &&
                   (mod.getRModuleOption(ao,it) == null)) {
                    if (log.isDebugEnabled()) {
                        log.debug("mapAttributeOptionToAllModuleIssueTypes(String, String) - Adding attribute to module/issuetype : ao=" + ao + ", rat=" + rat + ", it=" + it + ", mod=" + mod); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                    }
                    mod.addAttributeOption(it,ao);
                }                    
            }
            
            // add issuetype mappings
            iter = getIssueTypes(attribute).iterator();
            while (iter.hasNext()) {
                IssueType it = (IssueType) iter.next();
                try { 
                    it.addRIssueTypeOption(ao);
                } catch (TorqueException e) {
                    if (log.isEnabledFor(org.apache.log4j.Priority.WARN)) {
                        log
                                .warn(
                                        "mapAttributeOptionToAllModuleIssueTypes(String, String) - IssueTypeMApping alreadyt exists for this combination : attribute=" + attribute + ", option=" + option + ", it=" + it, null); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                    }
                }
            }

        }

    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void sortAttributeOptions(String attribute) throws Exception {
        Iterator iter;
        
        /**
         * Compare the order of  2 RModuleOptions based on their display value
         * 
         * @author pti
         *
         */
        final class RMOComparator implements Comparator {
            /**
             * Logger for this class
             */
            private final Logger log = Logger.getLogger(RMOComparator.class);

            public int compare(Object arg0, Object arg1) {
                // TODO Auto-generated method stub
                String s1 = ((RModuleOption)arg0).getDisplayValue();
                String s2 = ((RModuleOption)arg1).getDisplayValue();
                
                return s1.compareTo(s2);
            }
            
        };
        Comparator rmocomp = new RMOComparator();
        
        
        /**
         * Compare the order of  2 RIssueTypeOptions based on their display value
         * 
         * @author pti
         *
         */
        final class RIOComparator implements Comparator {
            /**
             * Logger for this class
             */
            private final Logger log = Logger.getLogger(RIOComparator.class);

            public int compare(Object arg0, Object arg1) {
                Integer oid1 = ((RIssueTypeOption)arg0).getOptionId();
                Integer oid2 = ((RIssueTypeOption)arg1).getOptionId();
                AttributeOption ao1=null;
                AttributeOption ao2=null;
                try {
                    ao1 = AttributeOptionPeer.retrieveByPK(oid1);
                    ao2 = AttributeOptionPeer.retrieveByPK(oid2);
                } catch (NoRowsException e) {
                    log.error("No Rows exception when sorting IssueTypeOptions.",e);
                } catch (TooManyRowsException e) {
                    log.error("Too many rows when sorting IssueTypeOptions.",e);
                } catch (TorqueException e) {
                    log.error("Torque exception when sorting IssueTypeOptions.",e);
                }
                
                return ao1.getName().compareTo(ao2.getName());
            }
            
        };
        Comparator riocomp = new RIOComparator();
        
        /**
         * Compare the order of  2 ParentChildAttributeOptions based on their display value
         * 
         * @author pti
         *
         */
        final class PCAOComparator implements Comparator {
            /**
             * Logger for this class
             */
            private final Logger log = Logger.getLogger(PCAOComparator.class);

            public int compare(Object arg0, Object arg1) {
                // TODO Auto-generated method stub
                String s1 = ((ParentChildAttributeOption)arg0).getName();
                String s2 = ((ParentChildAttributeOption)arg1).getName();
                
                return s1.compareTo(s2);
            }
            
        };
        Comparator pcaocomp = new PCAOComparator();
        
        
        Attribute attr = getAttribute(attribute);
        
        // sort module mappings
        iter = getModuleAttributes(attribute).iterator();
        while (iter.hasNext()) {
            RModuleAttribute rat = (RModuleAttribute) iter.next();
            IssueType it = rat.getIssueType();
            Module mod = rat.getModule();

            // skip template IssueTypes
            if (!isIssueTypeTemplate(it)) {
                List options = mod.getRModuleOptions(attr,it);
                Collections.sort(options, rmocomp);
                for (int i = 0; i < options.size(); i++) {
                    RModuleOption opt = (RModuleOption)options.get(i);
                    opt.setOrder(i + 1);
                    opt.save();
                }
                    
            }                    
        }
        
        // add issuetype mappings
        iter = getIssueTypes(attribute).iterator();
        while (iter.hasNext()) {
            IssueType it = (IssueType) iter.next();
            List options = it.getRIssueTypeOptions(attr);
            Collections.sort(options, riocomp);
            for (int i = 0; i < options.size(); i++) {
                RIssueTypeOption opt = (RIssueTypeOption)options.get(i);
                opt.setOrder(i + 1);
                opt.save();
            }
            
        }
        
        // sort pcao mappings
        List pcaos = attr.getParentChildAttributeOptions();
        Collections.sort(pcaos, pcaocomp);
        for (int i = 0; i < pcaos.size(); i++) {
            ParentChildAttributeOption opt = (ParentChildAttributeOption)pcaos.get(i);
            opt.setPreferredOrder(i + 1);
            opt.save();
        }

    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private void setAttributeOptionDeletedFlag(Attribute attr,
            AttributeOption option, boolean deleted) throws Exception {
        ParentChildAttributeOption pcao = ParentChildAttributeOption
                .getInstance();

        // claculate some sensible defaults
        int order = attr.getAttributeOptions().size() + 1;
        int weight = order;

        // populate the object and save it to db
        pcao.setAttributeId(attr.getAttributeId());
        pcao.setOptionId(option != null ? option.getOptionId() : null);
        pcao.setParentId(new Integer(0));
        pcao.setName(option.getName());
        pcao.setPreferredOrder(order);
        pcao.setWeight(weight);
        pcao.setDeleted(deleted);
        pcao.save();

    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public void updateAttributeOptions(String attribute, List options)
            throws Exception {
        SyncStateMap ssm = new SyncStateMap();
        Iterator iter = null;

        // Retrieve attribute to be updated
        iter = getAttributeOptions(attribute).iterator();
        while (iter.hasNext()) {
            
            ssm.getSyncState(((AttributeOption)iter.next()).getName()).setInternal(true);
        }

        // create SyncState info based on given external list.
        iter = options.iterator();
        while (iter.hasNext()) {
            String option = (String) iter.next();
            ssm.getSyncState(option).setExternal(true);
        }

        // iterate over the syncstates
        iter = options.iterator();
        while (iter.hasNext()) {
            String key = (String) iter.next();
            SyncState ss = ssm.getSyncState(key);
            if (ss.isExternal() && !ss.isInternal()) {
                // new in external data : add to attribute options
                addAttributeOption(attribute, key);
                mapAttributeOptionToAllModuleIssueTypes(attribute, key);
            } else if (!ss.isExternal() && ss.isInternal()) {
                // no longer in external data : remove from option list
                removeAttributeOption(attribute, key);
                mapAttributeOptionToAllModuleIssueTypes(attribute, key);
            }
        }
    }
            
// in java/org/tigris/scarab/screens/ScarabDefault.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        context.put("modulelink", new ModuleSwitchingLink(data));
    }
            
// in java/org/tigris/scarab/screens/ViewAttachment.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        
        String attachId = data.getParameters().getString("attachId");
        Attachment attachment = AttachmentManager
            .getInstance(new NumberKey(attachId), false);
        String contentType = attachment.getMimeType();
        HttpServletResponse res = data.getResponse();
        res.setContentType(contentType);
        // disposition header does not seem to have that much value, but
        // adding it in a blind attempt to help win2K, IE client
        // to handle the downloads better
        if (!contentType.startsWith("text")) 
        {
            res.setHeader("Content-Disposition", 
                          "attachment; filename=" + attachment.getFileName());
        }
        
        File f = new File(attachment.getFullPath());
        
        if(!f.exists())
        {
            LocalizationKey key = L10NKeySet.AttachmentDoesNotExist;
            L10NMessage msg = new L10NMessage(key,attachment.getFullPath());
            getScarabRequestTool(context).setAlertMessage(msg);
            data.setTarget("Error.vm");
        }
        else
        {
            res.setContentLength((int)f.length());

            BufferedInputStream bis = null;
            OutputStream os = data.getResponse().getOutputStream();
            try
            {
                bis = new BufferedInputStream(new FileInputStream(f));
                byte[] bytes = new byte[2048];
                int s = 0;
                while ((s = bis.read(bytes)) != -1)
                {
                    try
                    {
                        os.write(bytes,0,s);
                    }
                    catch (java.io.IOException ioe)
                    {
                        Log.get().debug("File download was aborted: " + 
                                        attachment.getFullPath());
                        break;
                    }
                }
            }
            finally
            {
                if (bis != null)
                {
                    bis.close();
                }
            }
        }
        // we already sent the response, there is no target to render
        data.setTarget(null);
    }
            
// in java/org/tigris/scarab/screens/ReportExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        TSVPrinter printer = new TSVPrinter(getWriter(data));

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ReportBridge report = scarabR.getReport();

        // --------------------------------------------------------
        // This code is not generally excercised as the action will 
        // not redirect to this screen if the following conditions are 
        // present.  But is here to protect against url hacking.
        try 
        {
            String message = (String)scarabR.getInfoMessage();
            if (message != null && message.length() > 0)
            {
                printer.print(message);
            }
        }
        catch (Exception e)
        {
            printer.print(l10n.get("ErrorOccurredCheckingMessage"));
        }
        
        if (!report.isReadyForCalculation()) 
        {
            printer.print(l10n.get("IncompleteReportDefinition"));
            return;
        }

        if (report.getReportDefinition().reportQueryIsExpensive()) 
        {
            printer.print(l10n.format("ReportIsTooExpensive", String.valueOf(
                report.getReportDefinition().maximumHeadings())));
            return;
        }
        // --------------------------------------------------------

        ReportTableModel model = report.getModel(user);

        List rowHeadings = model.getRowHeadings();
        List columnHeadings = model.getColumnHeadings();
        int multiplier = 1;
        for (int level = 0; level < columnHeadings.size(); level++)
        {
            ReportHeading columnHeadingLevel =
                (ReportHeading) columnHeadings.get(level);
            int maxBlank = rowHeadings.size() - 1;
            if (maxBlank > 0)
            {
                for (int i = 1; i <= maxBlank; i++)
                {
                    // Empty heading cell.
                    printer.print(NO_HEADER);
                }
            }

            boolean singleAttribute = columnHeadingLevel.singleAttribute();
            // It would be preferable to concatenate an arrow
            // pointing to the right to the return value of
            // displayAttribute(), but I wasn't able to come up with a
            // good "down arrow" for the X-axis headings.
            printer.print(singleAttribute
                          ? model.displayAttribute(columnHeadingLevel.get(0))
                          : NO_HEADER);
            int colspan = model.getColspan(level);
            for (int i = 1; i <= multiplier; i++)
            {
                for (int nextIndex = 1; nextIndex <= columnHeadingLevel.size();
                     nextIndex++)
                {
                    Object heading = columnHeadingLevel.get(nextIndex - 1);
                    printer.print(reportLabel(model, heading, singleAttribute,
                                              l10n));
                }
                if (colspan > 1)
                {
                    for (int j = 2; j <= colspan; j++)
                    {
                        printer.print(NO_HEADER);
                    }
                }
            }

            // End of first heading row.
            printer.println();
            multiplier *= columnHeadingLevel.size();
        }

        for (Iterator i = rowHeadings.iterator(); i.hasNext(); )
        {
            i.next();
            printer.print(NO_HEADER);
        }
        int nbrColumns = model.getColumnCount();
        for (int i = 0; i < nbrColumns; i++)
        {
            printer.print(NO_HEADER);
        }
        printer.println();

        int nbrRows = model.getRowCount();

        if (rowHeadings.size() > 1
            || ((ReportHeading) rowHeadings.get(0)).singleAttribute())
        {
            for (int level = 0; level < rowHeadings.size(); level++)
            {
                ReportHeading curHeading =
                    (ReportHeading) rowHeadings.get(level);
                boolean singleAttribute = curHeading.singleAttribute();
                // "Down arrow" is prepend to displayAttribute() in
                // web view.
                printer.print(singleAttribute
                              ? model.displayAttribute(curHeading.get(0))
                              : NO_HEADER);
                    
            }
            for (int i = 0; i < nbrRows; i++)
            {
                printer.print(NO_HEADER);
            }
            printer.println();
        }

        DateFormat dateFormat = new SimpleDateFormat(Format.DATE_TIME_FMT);
        for (int rowIndex = 0; rowIndex < nbrRows; rowIndex++)
        {
            for (int level = 0; level < rowHeadings.size(); level++)
            {
                ReportHeading curHeading =
                    (ReportHeading) rowHeadings.get(level);
                boolean singleAttribute = curHeading.singleAttribute();
                int rowspan = model.getRowspan(level);
                if ((rowIndex % rowspan) == 0)
                {
                    int index = (rowIndex / rowspan) % curHeading.size();
                    printer.print(reportLabel(model, curHeading.get(index),
                                              singleAttribute, l10n));
                }
                else
                {
                    printer.print(NO_HEADER);
                }
            }

            for (int columnIndex = 0; columnIndex < nbrColumns; columnIndex++)
            {
                Object cell = model.getValueAt(rowIndex, columnIndex);
                String cellData = (ReportTableModel.isDate(cell)
                                   ? dateFormat.format((Date) cell)
                                   : cell.toString());
                if (StringUtils.isEmpty(cellData))
                {
                    cellData = NO_CONTENT;
                }
                printer.print(cellData);
            }

            printer.println();
        }
    }
            
// in java/org/tigris/scarab/screens/SaveTemplate.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception
    {
        String title = null;
        try
        {
            if (scarabR.getIssueTemplate().getIssueId() == null)
            {
                title = l10n.get("SaveTemplate");
            }
            else 
            {
                String name = scarabR.getIssueTemplateInfo().getName();
                String editTemplate = l10n.get("EditTemplate");
                StringBuffer sb = new StringBuffer(name.length() + 
                                                   editTemplate.length() + 4);
                sb.append(editTemplate).append(" '").append(name).append('\'');
                title = sb.toString();
            }
        }
        catch (Exception e)
        {
            title = l10n.get("SaveTemplate");
            Log.get().debug("no current issue type, cannot retrieve SaveTemplate title", e);
        }
        return title;
    }
            
// in java/org/tigris/scarab/screens/IssueListExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        ctx = context;

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        MITList mitlist = user.getCurrentMITList();
        TSVPrinter printer = new TSVPrinter(getWriter(data));
        List rmuas = scarabR.getRModuleUserAttributes();
        writeHeading(printer, mitlist, l10n, rmuas);
        writeRows(printer, mitlist, l10n, scarabR, rmuas);
    }
            
// in java/org/tigris/scarab/screens/IssueListExport.java
private void writeHeading(TSVPrinter printer, MITList mitlist, 
                              ScarabLocalizationTool l10n, List rmuas)
        throws Exception
    {

        printer.print((new L10NMessage(L10NKeySet.IssueId).getMessage(l10n)));

        // ISSUE ATTRIBUTE VALUES as column headings.
        if (containsElements(rmuas)) 
        {
            int count=0;
            for (Iterator i = rmuas.iterator(); i.hasNext();) 
            {
                RModuleUserAttribute rmua = (RModuleUserAttribute)i.next();
                Attribute userAttribute = rmua.getAttribute();
                String attrName = rmua.getName(l10n);
                Module module = rmua.getModule();
                if (module != null && mitlist.isSingleModuleIssueType())
                {
                    RModuleAttribute attr = rmua.getModule().getRModuleAttribute(userAttribute, mitlist.getIssueType());
                    if (attr != null)
                        attrName = attr.getDisplayValue();
                }
                printer.print(attrName);
                attributeTypes.put(Integer.toString(count), userAttribute.getAttributeType().getName());
                count++;
            }
            
        }
    }
            
// in java/org/tigris/scarab/screens/IssueListExport.java
private void writeRows(TSVPrinter printer, MITList mitlist, 
            ScarabLocalizationTool l10n, ScarabRequestTool scarabR, List rmuas)
        throws Exception
    {
        for (Iterator i = scarabR.getCurrentSearchResults().iterator();i.hasNext();)
        {
            printer.println();
            QueryResult queryResult = (QueryResult)i.next();
            writeRow(printer, mitlist, queryResult);
        }
        // print a newline when we're done to complete the last line;
        // this also ensures that the output is flushed
        printer.println();
    }
            
// in java/org/tigris/scarab/screens/IssueListExport.java
private void writeRow(TSVPrinter printer, MITList mitlist, QueryResult queryResult)
        throws Exception
    {

        printer.print(queryResult.getUniqueId());

        List values = queryResult.getAttributeValuesAsCSV();
        if (containsElements(values)) 
        {
            int count=0;
            for (Iterator itr = values.iterator();itr.hasNext();)
            {
                String val = (String)itr.next();
                String type = (String)attributeTypes.get(Integer.toString(count));
                count++;
                if (type.equals("date"))
                    val = DateAttribute.dateFormat(val, (new L10NMessage(L10NKeySet.ShortDatePattern).getMessage(getLocalizationTool(ctx))));
                if (val.length() == 0)
                {
                    printer.print(NO_CONTENT);
                }
                else
                {
                    printer.print(val);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/screens/ViewIssue.java
protected void doBuildTemplate(RunData data, TemplateContext context) throws Exception
    {
        super.doBuildTemplate(data, context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = null;
        
        String id = data.getParameters().getString("id");
		try{
			issue = getReferredIssue(id == null ? null : id.trim(), (ScarabModule)scarabR.getCurrentModule());
		}
		catch(Exception e){
			//ignore, this case will be handled later: issue == null
		}
        boolean hasViewPermission = false;
        boolean hasDeletePermission = false;
        // Deleted issues will appear to not have existed before
        if (issue == null || issue.getDeleted())
        {
             L10NMessage msg = new L10NMessage(L10NKeySet.IssueIdNotValid, id);
             scarabR.setAlertMessage(msg);
        }
        else
        {
            hasViewPermission = scarabR.hasPermission(ScarabSecurity.ISSUE__VIEW, issue.getModule());
            hasDeletePermission=scarabR.hasPermission(ScarabSecurity.ISSUE__DELETE, issue.getModule());
            context.put("currentIssue", issue);
            context.put("hasViewPermission", hasViewPermission?Boolean.TRUE:Boolean.FALSE);
            context.put("hasDeletePermission", hasDeletePermission?Boolean.TRUE:Boolean.FALSE);
            context.put("additionalDisplayAttributes", getAdditionalDisplayAttributes());
            if (!hasViewPermission)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.NoPermissionToViewIssue, id);
                scarabR.setAlertMessage(msg);
            }
            else if (issue.getMoved())
            {
                ScarabLink link = (ScarabLink)context.get("link");
                Issue newIssue = scarabR.getIssueIncludingDeleted(issue.getIssueNewId());
                L10NMessage msg = new L10NMessage(L10NKeySet.IssueIsNowLocatedIn,
                        link.getIssueIdLink(newIssue), newIssue.getUniqueId());
                scarabR.setAlertMessage(msg);
            }
        }
    }
            
// in java/org/tigris/scarab/screens/ViewIssue.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception
    {
        String title = (new L10NMessage(L10NKeySet.ViewIssue).getMessage(l10n));
        String currentIssueId = data.getParameters().getString("id");
        Issue issue = null;
        if (currentIssueId != null)
        {
            issue = scarabR.getIssue(currentIssueId);
        }
        if (issue != null) 
        {
            String name = issue.getModule().getRModuleIssueType(issue.getIssueType()).getDisplayName();
            String id = (new L10NMessage(L10NKeySet.ID).getMessage(l10n));
            String unique = issue.getUniqueId();
            title = name + " " + id + ": " + unique;
        }            
        return title;
    }
            
// in java/org/tigris/scarab/screens/ViewIssue.java
private List getAdditionalDisplayAttributes()
        throws Exception
    {
        List displayAttributeNames = GlobalParameterManager.getStringList(
            ADDITIONAL_DISPLAY_ATTRIBUTES
        );

        List displayAttributes = new ArrayList();
        for(Iterator names=displayAttributeNames.iterator();names.hasNext();)
        {
            final String displayAttributeName = (String)names.next();
            
            for(Iterator attributes = AttributePeer.getAttributes().iterator();attributes.hasNext();)
            {
                Attribute attribute = (Attribute)attributes.next();
                if(displayAttributeName.equals(attribute.getName())){
                    displayAttributes.add(attribute);
                }
            }
        }
        return displayAttributes;
    }
            
// in java/org/tigris/scarab/screens/IssueList.java
protected void doBuildTemplate(RunData data, TemplateContext context)
    throws Exception
    {
        super.doBuildTemplate(data, context);
        populateContextWithQueryResults(data, context);
        
    }
            
// in java/org/tigris/scarab/screens/IssueList.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n)
        throws Exception
    {
        if (scarabR.getQuery() != null
            && StringUtils.isNotBlank(scarabR.getQuery().getName()))
        {
            return l10n.format("IssueList.vm.TitleWithQueryName",
                               scarabR.getQuery().getName());
        }
        else
        {
            return super.getTitle(scarabR,l10n);
        }
    }
            
// in java/org/tigris/scarab/screens/SelectModule.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        context.put("modulelink", new ModuleSwitchingLink(data));
    }
            
// in java/org/tigris/scarab/screens/home/XModuleList.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        ScarabUser user = (ScarabUser)data.getUser();
        MITList currentList = user.getCurrentMITList();
        if (currentList != null && !currentList.isModifiable()) 
        {
            user.setCurrentMITList(null);
        }
    }
            
// in java/org/tigris/scarab/screens/IssueTypeList.java
protected void doBuildTemplate(RunData data, TemplateContext context) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module module = scarabR.getCurrentModule();
        if (null == module || module.getIssueTypes() == null || module.getIssueTypes().size() == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.NoIssueTypesAssociatedToModule);
            context.put("issueTypesAvailaible", Boolean.FALSE);
        }
        else
        {
            context.put("issueTypesAvailaible", Boolean.TRUE);
        }
        super.doBuildTemplate(data, context);
    }
            
// in java/org/tigris/scarab/screens/Default.java
public String doBuild(RunData data) throws Exception
    {
        super.doBuild(data);
        return "";
    }
            
// in java/org/tigris/scarab/screens/Default.java
protected void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        // This may not be the best location for this, we might need to create
        // a valve.
        // check that the module exists, it may not have been created yet.
        try
        {
            scarabR.getCurrentModule();
        }
        catch (Exception ignore)
        {
        }

        // add the title text to the context.
        ScarabLocalizationTool l10n =
            (ScarabLocalizationTool) context.get("l10n");

        // Determine whether this target requires issue types.
        String altTarget = getTargetForNoIssueTypes(data);
        boolean changeTarget = false;
        if (altTarget != null)
        {
            List issueTypes = scarabR.getCurrentModule().getIssueTypes(true);
            changeTarget = (issueTypes == null || issueTypes.isEmpty());
        }

        if (changeTarget)
        {
            // Pass control to the alternate target.
            scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
            setTarget(data, altTarget);
        }
        else
        {
            // Add the title text to the context.
            String title = null;
            try
            {
                title = getTitle(scarabR, l10n);
            }
            catch (Exception e)
            {
                Log.get().info(
                    "Error getting page title for Screen: " + data.getTarget());
            }
            if (title == null)
            {
                title = "Scarab";
            }
            context.put("title", title);
        }
    }
            
// in java/org/tigris/scarab/screens/Default.java
protected String getTitle(ScarabRequestTool scarabR, ScarabLocalizationTool l10n)
        throws Exception
    {
        return l10n.getTitle();
    }
            
// in java/org/tigris/scarab/screens/Default.java
protected boolean isAuthorized(RunData data) throws Exception
    {
        return checkAuthorized(data);
    }
            
// in java/org/tigris/scarab/screens/Default.java
public static boolean checkAuthorized(RunData data) throws Exception
    {
        String template = data.getTarget();
        {
            template = template.replace(',', '.');
            String perm = ScarabSecurity.getScreenPermission(template);
            TemplateContext context = getTemplateContext(data);
            ScarabRequestTool scarabR = getScarabRequestTool(context);
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            Module currentModule = scarabR.getCurrentModule();
            ScarabUser user = (ScarabUser) data.getUser();
            if (perm != null)
            {
                if (!user.hasLoggedIn()
                    || !user.hasPermission(perm, currentModule))
                {
                    scarabR.setInfoMessage(L10NKeySet.LoginToAccountWithPermissions);
                    // it is very common to come from email to view a
                    // particular issue.  Until a more general formula for
                    // deciding which requests might be ok to continue after
                    // a login, we will at least allow this one.
                    if ("ViewIssue.vm".equals(data.getTarget()))
                    {
                        data.getParameters().setString(
                            "viewIssueId",
                            data.getParameters().getString("id"));
                    }

                    setTargetLogin(data);
                    scarabR.setCurrentModule(null);
                    return false;
                }
                else if (currentModule == null)
                {
                    Log.get().debug("Current module is null");
                    scarabR.setInfoMessage(L10NKeySet.SelectModuleToWorkIn);
                    setTargetSelectModule(data);
                    return false;
                }
            }
            // does the user at least have a role in the module?
            // we don't check user.hasLoggedIn() here because guest
            // users could have a role in a module.
            else if (
                currentModule != null && !user.hasAnyRoleIn(currentModule) 
                     && !user.hasAnyRoleIn(
                         ModuleManager.getInstance(Module.ROOT_ID)))
            {
                if (Log.get().isDebugEnabled())
                {
                    Log.get().debug(
                        "User ("
                            + user.getUserId()
                            + ") did not have any roles in current module"
                            + currentModule.getName());
                }
                scarabR.setCurrentModule(null);
                data.getParameters().remove(ScarabConstants.CURRENT_MODULE);
                scarabR.setAlertMessage(L10NKeySet.NoPermissionInModule);
                setTargetSelectModule(data);
                return false;
            }
            /* FIXME
               Breaks the ability to request roles because the permission is null and
               the module is null, but we are logged in. John, we should assign default
               permissions to each screen so that we can make it so that someone can be
               logged in, but not select a module yet and be shown the select module
               screen. (JSS)
            
                        else if (currentModule == null &&
                                 user != null &&
                                 user.hasLoggedIn())
                        {
                            setTargetSelectModule(data);
                            return true;
                        }
            */
        }
        return true;
    }
            
// in java/org/tigris/scarab/screens/admin/AttributeOptionSelect.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       String name = scarabR.getAttribute().getName();
       return l10n.format("AddGlobalAttributeOptionToAttribute", name);
    }
            
// in java/org/tigris/scarab/screens/admin/ViewXMLExportIssues.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
              
        super.doBuildTemplate(data, context);

        // probably should use intake, but i'm being lazy for now cause
        // this is only three form variables and not worth the trouble...
        // [hair] it is actually very useful that data.getParameters() is used
        // because it means that the xml results can be fetched through a Http GET
        // as well as the normal POST.
        String filename = data.getParameters().getString("filename");
        if (filename == null 
            || filename.length() == 0 
            || filename.indexOf('/') > 0
            || filename.indexOf(':') > 0
            || filename.indexOf(';') > 0)
        {
            filename = "scarab-issues-export.xml";
        }

        final ScarabRequestTool scarabR = getScarabRequestTool(context);
        final Module currentModule = scarabR.getCurrentModule();
        final ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        final ScarabUser user = (ScarabUser)data.getUser();
        
        // new functionality allows query parameter to select which issues to print
        final String query = data.getParameters().getString("go");
        String ids = null;
        final List allIdList = new ArrayList();
        if( query != null )
        {
            final StringBuffer sb = new StringBuffer();
            final Search searchAction = new Search();
            searchAction.doSelectquery(data, context);
            final Iterator it = scarabR.getCurrentSearchResults().iterator();
            while(it.hasNext())
            {
                final QueryResult issue = (QueryResult)it.next();
                // only add the result if the user would otherwise be able to view it.
                if( user.hasPermission(ScarabSecurity.ISSUE__VIEW, issue.getIssue().getModule()) ){
                    
                    sb.append(issue.getIssue().getIdPrefix()+issue.getIssue().getIdCount());
                    allIdList.add(issue.getIssue().getIdPrefix()+issue.getIssue().getIdCount());
                    if(it.hasNext())
                    {
                        sb.append(',');
                    }
                }
            }
            ids = sb.toString();
        }else{
            // issues are defined manually
            ids = data.getParameters().getString("exportissues");
        }
        context.put("exportissues", ids);
        if (ids == null || ids.length() == 0)
        {
            data.setTarget("admin,XMLExportIssues.vm");
            scarabR.setAlertMessage(l10n.get("EnterIssues"));
            return;
        }
        else
        {
            // manually specified ids we need parse & verify
            if( allIdList.isEmpty() )
            {
                try
                {
                    // FIXME! we need this method to return valid ids, if the range
                    // is thousands of issues, we cannot post verify the issues.
                   allIdList.addAll( Issue.parseIssueList(currentModule, ids) );
                }
                catch (Exception e)
                {
                    data.setTarget("admin,XMLExportIssues.vm");
                    scarabR.setAlertMessage(l10n.getMessage(e));
                    return;
                }
            }
            final List issueIdList = new ArrayList();
            final List badIdList = new ArrayList();
            final Integer currentModuleId = currentModule.getModuleId();
            final String defaultCode = currentModule.getCode();
            for (Iterator itr = allIdList.iterator(); itr.hasNext();)
            {
                final String tmp = (String) itr.next();
                final Issue issue = IssueManager.getIssueById(tmp, defaultCode);
                // check that the issue is in the current module, don't allow
                // exporting of issues other than those in the current
                // module for security reasons
                if (issue != null && !issue.getDeleted() )
                {
                    issueIdList.add(tmp);
                }
                else
                {
                    badIdList.add(tmp);
                }
            }
            if (issueIdList.isEmpty())
            {
                data.setTarget("admin,XMLExportIssues.vm");
                scarabR.setAlertMessage(l10n.get("NoValidIssuesCouldBeLocated"));
                return;
            }
            else if (!badIdList.isEmpty())
            {
                data.setTarget("admin,XMLExportIssues.vm");
                scarabR.setAlertMessage(
                    l10n.format("FollowingIssueIdsAreInvalid", 
                    badIdList.toString()));
                return;
            }

            String contentType;
            String contentDisposition;
            if ("1".equals(data.getParameters().getString("downloadtype")))
            {
                // To browser window.
                contentType = "text/xml";
                contentDisposition = "inline";
            }
            else
            {
                // Save to file.  Unforunately, not all browsers are
                // created equal, and some fail to fully heed the
                // Content-disposition header.  We hack around this by
                // using a Content-type header which indicates binary
                // data.
                //contentType = "text/xml";
                contentType = "application/octet-stream";
                contentDisposition = "attachment";
            }
            data.getResponse().setContentType(contentType);
            data.getParameters().add("content-type", contentType);
            contentDisposition += "; filename=" + filename;
            data.getParameters().add("content-dispostion", contentDisposition);
            data.getResponse().setHeader("Content-Disposition",
                                         contentDisposition);
    
            context.put("issueIdList", issueIdList);
            final VelocityContext vc = new VelocityContext();
            for (Iterator keys = context.keySet().iterator(); keys.hasNext(); )
            {
                final String key = (String) keys.next();
                vc.put(key, context.get(key));
            }
            vc.put("dtdURI", ImportIssues.SYSTEM_DTD_URI);

            final String encoding = Turbine.getConfiguration()
                .getString("scarab.dataexport.encoding");
            if (encoding != null && !encoding.equals(""))
            {
                TurbineVelocity.handleRequest
                    (vc, "macros/XMLExportIssuesMacro.vm",
                     data.getResponse().getOutputStream(), encoding, encoding);
            }
            else
            {
                TurbineVelocity.handleRequest
                    (vc, "macros/XMLExportIssuesMacro.vm",
                     data.getResponse().getOutputStream());
            }
    
            // we already sent the response, there is no target to render
            data.setTarget(null);
        }
    }
            
// in java/org/tigris/scarab/screens/admin/ViewXMLExportSettings.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);

        // probably should use intake, but i'm being lazy for now cause
        // this is only three form variables and not worth the trouble...
        String downloadType = data.getParameters().getString("downloadtype");
        if (downloadType != null && downloadType.equals("1"))
        {
            data.getResponse().setContentType("text/plain");
        }
        else
        {
            data.getResponse().setContentType("application/octet-stream");
            String filename = data.getParameters().getString("filename");
            if (filename == null 
                || filename.length() == 0 
                || filename.indexOf('/') > 0
                || filename.indexOf(':') > 0
                || filename.indexOf(';') > 0)
            {
                filename = "scarab-settings-export.xml";
            }
            data.getResponse().setHeader("Content-Disposition", 
                "attachment; filename=" + filename);
        }

        String includeUsers = data.getParameters().getString("includeUsers");
        if (includeUsers != null && includeUsers.equals("1"))
        {
            context.put ("includeUsers", Boolean.TRUE);
        }
        else
        {
            context.put ("includeUsers", Boolean.FALSE);
        }
        
        context.put("renderedFromScreen", Boolean.TRUE);
        context.put("sdf", new SimpleDateFormat(ScarabConstants.DATE_FORMAT));
        String result = 
            Module.handleRequest (context, "macros/XMLExportSettingsMacro.vm");
        data.getResponse().setContentLength(result.length());
        data.getResponse().getOutputStream().print(result);
        context.remove("renderedFromScreen");

        // we already sent the response, there is no target to render
        data.setTarget(null);
    }
            
// in java/org/tigris/scarab/screens/admin/ArtifactTypeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   { 
       String name = scarabR.getCurrentModule().getRModuleIssueType(scarabR.getIssueType()).getDisplayName();
       return l10n.format("EditIssueType", name);
    }
            
// in java/org/tigris/scarab/screens/admin/GlobalArtifactTypeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       IssueType issueType = scarabR.getIssueType();
       String title = null;
       if (issueType.getIssueTypeId() != null)
       {
           String name = issueType.getName();
           title = l10n.format("EditGlobalIssueType", name);
       }
       else 
       {
           title = l10n.get("CreateNewIssueType");            
       }
       return title;
    }
            
// in java/org/tigris/scarab/screens/admin/UserAttributeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       Attribute attribute = scarabR.getAttribute();
       String title = null;
       if (attribute.getAttributeId() != null)
       {
           String name = attribute.getName();
           title = l10n.format("EditGlobalUserAttribute", name);
       }
       else 
       {
           title = l10n.get("CreateNewGlobalUserAttribute");            
       }
       return title;
    }
            
// in java/org/tigris/scarab/screens/admin/ManageArtifactTypes.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
           return l10n.format("ManageIssueTypes", 
                              scarabR.getCurrentModule().getRealName());
    }
            
// in java/org/tigris/scarab/screens/admin/ActivityList.java
protected void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        ParameterParser pp = data.getParameters();
        String fromPk = pp.getString("frompk");
        String toPk = pp.getString("topk");
        String fromDateString = pp.getString("fromdate");
        String toDateString = pp.getString("todate");
        boolean isByPk = "pk".equals(pp.get("sort")) || (fromPk != null)
            || (toPk != null);
        // max=# will give the number of records, -1 will return all records
        //int max = pp.getInt("max", 100);

        Criteria crit = new Criteria();
        Criteria.Criterion c = null;
        if (isByPk) 
        {
            crit.addAscendingOrderByColumn(ActivitySetPeer.TRANSACTION_ID);
            if (fromPk != null) 
            {
                c = crit.getNewCriterion(ActivitySetPeer.TRANSACTION_ID, 
                                         fromPk, Criteria.GREATER_EQUAL);
            }
            if (toPk != null) 
            {
                if (c == null) 
                {
                    c = crit.getNewCriterion(ActivitySetPeer.TRANSACTION_ID, 
                                             toPk, Criteria.LESS_EQUAL);
                }
                else 
                {
                    c.and(crit.getNewCriterion(ActivitySetPeer.TRANSACTION_ID, 
                                               toPk, Criteria.LESS_EQUAL));
                    
                }
            }
        }
        else 
        {
            crit.addAscendingOrderByColumn(ActivitySetPeer.CREATED_DATE);

            if (fromDateString != null) 
            {
                c = crit.getNewCriterion(ActivitySetPeer.CREATED_DATE, 
                                         parseDate(fromDateString), 
                                         Criteria.GREATER_EQUAL);
            }

            if (toDateString != null) 
            {
                if (c == null) 
                {
                    c = crit.getNewCriterion(ActivitySetPeer.CREATED_DATE, 
                                             parseDate(toDateString), 
                                             Criteria.LESS_EQUAL);
                }
                else 
                {
                    c.and(crit.getNewCriterion(ActivitySetPeer.CREATED_DATE, 
                                               parseDate(toDateString), 
                                               Criteria.LESS_EQUAL));
                }
            }
        }
        if (c != null) 
        {
            crit.add(c);
        }
        
        final List sets = ActivitySetPeer.doSelect(crit);
        // the following iterator starts at the end of the list and
        // iterates toward the beginning, removing items from the list
        // as it goes.  This helps with memory usage.  The original list
        // size can still be too large, but if it is not, processing by
        // the template should not add additional memory burden.
        Iterator setIterator = new Iterator()
            {
                public boolean hasNext()
                {
                    return !sets.isEmpty();
                }

                public Object next()
                {
                    ScarabCache.clear();
                    return sets.remove(sets.size()-1);
                }

                public void remove()
                {
                    //not implemented
                }
            };
        context.put("activitySets", setIterator);
    }
            
// in java/org/tigris/scarab/screens/admin/GlobalAttributeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       Attribute attribute = scarabR.getAttribute();
       String title = null;
       if (attribute.getAttributeId() != null)
       {
           String name = attribute.getName();
           title = l10n.format("EditGlobalAttribute", name);
       }
       else 
       {
           title = l10n.get("CreateNewGlobalAttribute");            
       }
       return title;
    }
            
// in java/org/tigris/scarab/screens/admin/ModuleAttributeEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       Attribute attribute = scarabR.getAttribute();
       Module module = scarabR.getCurrentModule();
       IssueType issueType = scarabR.getIssueType();
       
       String title;
       if (attribute == null) 
       {
           title = l10n.get("NoAttributeToEdit");
           Log.get().warn(
               "No attribute id was specified for ModuleAttributeEdit.");
       }
       else 
       {
           if (module == null || issueType == null)
           {
               // such a condition is probably going to give errors
               // elsewhere, but we can at least return a global name.
               title = attribute.getName();
               Log.get().warn("Current module or issue type id was not " +
                               "specified for ModuleAttributeEdit");
           }
           else 
           {
               RModuleAttribute rma = module
                   .getRModuleAttribute(attribute, issueType);
               if (rma == null) 
               {
                   // again, such a condition is probably going to give errors
                   // elsewhere, but we can at least return a global name.
                   title = attribute.getName();           
                   Log.get().warn(
                       "rma is null in ModuleAttributeEdit.");
               }
               else 
               {
                   title = rma.getDisplayValue();
               }
           }
       }

       return l10n.format("EditModuleAttribute", title);
    }
            
// in java/org/tigris/scarab/screens/admin/ModuleAttributeEdit.java
public void doBuildTemplate(RunData data, TemplateContext context)
    throws Exception
    {
    	super.doBuildTemplate(data, context);
    	
    	// workaround to avoid calling the same template once again as cancel template
    	// SCB2624
    	String cancelTemplate = getCancelTemplate(data);
    	if(cancelTemplate == null || cancelTemplate.equals("admin,ModuleAttributeEdit.vm")){
    		data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE, "admin,AttributeGroupEdit.vm");
    	}
    	
    }
            
// in java/org/tigris/scarab/screens/admin/AttributeGroupEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
       String groupId = data.getParameters().getString("groupid");
       AttributeGroup group = scarabR.getAttributeGroup(groupId);
       String title = null;
       if (group == null) 
       {
           title = l10n.get("AddAttributeGroup");
       }
       else 
       {
           title = l10n.format("EditAttributeGroup", group.getName());
       }
       return title;
    }
            
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
public void doBuildTemplate(final RunData data, 
            final TemplateContext context)
        throws Exception
    {
        
        String resultString = "";
        int resultCode = RESULT_OK;
        Collection importErrors = null;
        ScarabIssues si = null;

        super.doBuildTemplate(data, context);
        final ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        if (isImportAuthorized(data))
        {
            final FileItem issuesToImport = data.getParameters()
                .getFileItem("issues");
            
            if (issuesToImport != null 
                && issuesToImport.getSize() >= MIN_XML_SIZE)
            {
                try
                {
                    final ScarabUser user = (ScarabUser)data.getUser();
                    final ImportIssues importIssues = new ImportIssues(
                            user.hasPermission(ScarabSecurity.DOMAIN__ADMIN, (Module)null),
                            user.hasPermission(ScarabSecurity.DOMAIN__ADMIN, (Module)null),
                            data.getServletConfig().getServletContext().getRealPath("/") + "/WEB-INF/attachments/");
                    final ScarabRequestTool scarabR = getScarabRequestTool(context);
                    final String type = data.getParameters().getString("xmlFormat");
                    
                    importErrors = importIssues.runImport(
                            issuesToImport, 
                            scarabR.getCurrentModule(),
                            ImportIssues.ImportType.valueOf(type));
                    
                    si = importIssues.getScarabIssuesBeanReader();
                    if (importErrors != null && !importErrors.isEmpty())
                    {
                        resultCode = RESULT_ERROR_INVALID_ISSUE_DATA;
                        resultString = l10n.get("ProcessingErrors");
                    }
                }
                catch (Exception e)
                {
                    resultCode = RESULT_ERROR_EXCEPTION;
                    // TODO: Improve localizability of this text.
                    resultString = l10n.get("ProcessingErrors") + ": "
                        + e.getMessage();
                }
            }
            else
            {
                resultCode = RESULT_ERROR_XML_MISSING;
                resultString = l10n.get("MissingXML");
            }
        }
        else
        {
            resultCode = RESULT_ERROR_UNAUTHORIZED;
            resultString = l10n.get("Unauthorized");
        }

        context.put("resultString", resultString);
        context.put("resultCode", new Integer(resultCode));
        context.put("importErrors", importErrors);
        context.put("issues", si);
        
        final String format = data.getParameters().getString("format");
        if (format != null && format.equals("xml")) 
        {
            final String result = org.apache.turbine.modules.Module.handleRequest
                (context, "macros/XMLImportIssuesResultsMacro.vm");
            data.getResponse().setContentType("text/plain");
            data.getResponse().setContentLength(result.length());
            data.getResponse().getOutputStream().print(result);
    
            // we already sent the response, there is no target to render
            data.setTarget(null);
        }
    }
            
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
protected boolean isAuthorized(RunData data) throws Exception
    {
        return (true);
    }
            
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
private boolean isImportAuthorized(RunData data) 
        throws Exception
    {
        String perm = ScarabSecurity.getScreenPermission
            ("admin.XMLImportIssuesResults.vm");
        TemplateContext context = getTemplateContext(data);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module currentModule = scarabR.getCurrentModule();
        ScarabUser user = (ScarabUser) data.getUser();
        boolean result = false;

        if (perm != null) // Is there is a permission for this?
        {
            if (user.hasLoggedIn() &&
                    user.hasPermission(perm, currentModule))
            {
                result = true; // Confirmed user has permission
            }
        }
        else
        {
            result = true; // No permission = unsecured
        }

        return (result);
    }
            
// in java/org/tigris/scarab/screens/admin/ConditionEdit.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   { 
       String name = scarabR.getCurrentModule().getRModuleIssueType(scarabR.getIssueType()).getDisplayName();
       return l10n.format("ConditionEdit", name);
    }
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
			throws Exception {
		super.doBuildTemplate(data, context);

		data.getResponse().setContentType(MIME_TYPE);

		// we will send the response, so no target to render
		data.setTarget(null);
		
		Writer writer = data.getResponse().getWriter();
		
		try {
            ParameterParser parser = data.getParameters();



            String feedType = parser.getString(FEED_TYPE_KEY);
            if(feedType == null)
            {
                String msg = COULD_NOT_FIND_FEED_TYPE;
                Log.get().error(msg);
                data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);            
                return;
            }

            String feedFormat = parser.getString(FEED_FORMAT_KEY);

            ScarabLink scarabLink= getScarabLinkTool(context);
            
            Feed feedSource = null;
            if (feedType.equals("IssueFeed")){
                String issueId = parser.getString(ISSUE_ID_KEY);                
                if(issueId.equals("")){
                    throw new IllegalArgumentException("Issue ID is missing.  Should be appended like: /issueId/xxx");
                }            	
            	Issue issue = IssueManager.getIssueById(issueId);
            	feedSource = new IssueFeed(issue,scarabLink, getLocalizationTool(context));
            }
            else {
            	throw new Exception("Couldn't find feed for type:" + feedType);
            }
            SyndFeed feed = feedSource.getFeed();

            feedFormat = (feedFormat!=null) ? feedFormat : DEFAULT_FEED_FORMAT;
            feed.setFeedType(feedFormat);

            
            SyndFeedOutput output = new SyndFeedOutput();
            output.output(feed,writer);
        }
        catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }        
        catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }      		
	}
            
// in java/org/tigris/scarab/screens/entry/Wizard1.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception
    {
        Issue newIssue = scarabR.getReportingIssue();
        IssueType issueType = newIssue.getIssueType();
        RModuleIssueType rmit = newIssue.getModule()
            .getRModuleIssueType(issueType);
        String name;
        if (rmit == null)
        {
            name = issueType.getName();
            Log.get().warn("Used global name of issueType, " + name + 
                           ", but the module version should be available.");
        }
        else
        {
            name = rmit.getDisplayName();
        }

        return l10n.format("EnterNewIssueType", name);
    }
            
// in java/org/tigris/scarab/screens/DataExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
        throws Exception 
    {
        super.doBuildTemplate(data, context);
        String format = ScarabUtil.findValue(data, ExportFormat.KEY_NAME);

       log.debug("Export for format: " + format);
        
        // look for a configuration toggle for the encoding to which to
        // export.  TODO : make this per request configurable (with a per-
        // language default) to allow use of scarab in a multilingual 
        // environment.
        if (ExportFormat.EXCEL_FORMAT.equalsIgnoreCase(format))
        {
            data.getResponse().setContentType("application/vnd.ms-excel");
        }
        else
        {
            // we want to set a charset on the response -- so clients
            // can detect it properly -- if we have a known encoding
            String encoding = getEncodingForExport(data);
            String contentType = "text/tab-separated-values";
            if (encoding != null && !encoding.equals(""))
            {
                contentType = contentType + "; charset=" + encoding;
            }
            data.getResponse().setContentType(contentType);
        }
        // Since we're streaming the TSV content directly from our
        // data source, we don't know its length ahead of time.
        //data.getResponse().setContentLength(?);
        
        // FIXME: Provide work hooks here...
        //TSVPrinter printer = new TSVPrinter(data.getResponse().getWriter());
        //writeHeading(printer, mitlist, l10n, rmuas);
        //writeRows(printer, mitlist, l10n, scarabR, rmuas);

        // Above we sent the response, so no target to render
        data.setTarget(null);
    }
            
// in java/org/tigris/scarab/screens/AssignIssue.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception 
   {
        String[] issueIdList = data.getParameters().getStrings("issue_ids");
        String singleIssue = data.getParameters().getString("issueId");
        Integer size = null;
        if (issueIdList == null) 
        {
            size = new Integer(0);
        }
        else if (singleIssue != null)
        {
            size = new Integer(1);
        }
        else 
        {
            size = new Integer(issueIdList.length);
        }
        return l10n.format("AssignUsersWithThisIssue", size);
    }
            
// in java/org/tigris/scarab/screens/ConfigureIssueList.java
protected void doBuildTemplate(RunData data, TemplateContext context) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        List attributes = scarabR.getAllValidIssueListAttributes();
        for (Iterator it = RModuleUserAttribute.internalAttributes.iterator(); it.hasNext(); )
        {
            attributes.add(it.next());
        }
        context.put("attributepreferences", scarabR.getRModuleUserAttributes());
        context.put("attributes", attributes);
        super.doBuildTemplate(data, context);
    }
            
// in java/org/tigris/scarab/screens/MoveIssue.java
protected String getTitle(ScarabRequestTool scarabR,
            ScarabLocalizationTool l10n)
    	throws Exception
    {
    	return getTitle(scarabR, l10n, data, context);
    }
            
// in java/org/tigris/scarab/screens/MoveIssue.java
protected String getTitle(ScarabRequestTool scarabR,
                              ScarabLocalizationTool l10n,
                              RunData data, TemplateContext context)
        throws Exception
    {
        String title = null;
        try
        {
            String action = ((IntakeTool) context.get("intake"))
                .get("MoveIssue").getDefault().get("Action").toString();
            String l10nKey = getKey();
            if (COPY.equals(action))
            {
                title = l10n.format(l10nKey, COPY_CHOICE);
            }
            else if (MOVE.equals(action))
            {
                title = l10n.format(l10nKey, MOVE_CHOICE);
            }
            else 
            {
                scarabR.setAlertMessage(l10n.get("NoActionSpecified"));
                setTarget(data, "ViewIssue.vm");
            }
        }
        catch (Exception e)
        {
            title = "Error; Copy or Move?";
            Log.get().warn("Error determining title", e);
        }
        return title;
    }
            
// in java/org/tigris/scarab/screens/MoveIssue.java
protected void doBuildTemplate(RunData data, TemplateContext context)
    	throws Exception
    {
    	this.data = data;
    	this.context = context;
    	super.doBuildTemplate(data, context);
    }
            
// in java/org/tigris/scarab/screens/notifications/NotificationList.java
protected void doBuildTemplate(RunData data, TemplateContext context) throws Exception
    {
        List notifs = NotificationStatusManager
                .getNotificationsFor((ScarabUser) data.getUser());
        OrderedMap issueSets = new ListOrderedMap();
        for (Iterator it = notifs.iterator(); it.hasNext(); )
        {
            NotificationStatus notif = (NotificationStatus)it.next();
            Issue issue = notif.getActivity().getIssue();
            OrderedMap setActivities = (OrderedMap)issueSets.get(issue);
            if (null == setActivities)
            {
                setActivities = new ListOrderedMap();
                issueSets.put(issue, setActivities);
            }
            Activity act = notif.getActivity();
            ActivitySet set = act.getActivitySet();
            List notifications = (List)setActivities.get(set);
            if (null == notifications)
            {
                notifications = new ArrayList();
                setActivities.put(set, notifications);
            }
            notifications.add(notif);
        }
        context.put("notificationStructure", issueSets);
        super.doBuildTemplate(data, context);
    }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
public SyndFeed getFeed() throws IOException, FeedException, TorqueException, Exception {

        SyndFeed feed = new SyndFeedImpl();
       
        String title = issue.getUniqueId() + ": " + issue.getDefaultText();
        feed.setTitle(title);
        String link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
        feed.setLink(link);
        feed.setDescription(title);

        List entries = new ArrayList();
        List allActivities = issue.getActivity(true);
        

        for (Iterator i = allActivities.iterator(); i.hasNext();) {
            SyndEntry entry;
            SyndContent description;
            
            Activity activity = (Activity)i.next();
            
            ActivitySet activitySet = activity.getActivitySet();
            Date date =activitySet.getCreatedDate();
            entry = new SyndEntryImpl();

            entry.setPublishedDate(date);
            
            description = new SyndContentImpl();
            description.setType("text/html");
            
            String desc =
                  "<b>Description:</b>" + activity.getDisplayName(this.l10nTool) +"<br/>"
                + "<b>New:</b>" + activity.getNewValue(this.l10nTool) +"<br/>"
                + "<b>Old:</b>" + activity.getOldValue(this.l10nTool) +"<br/>"
                + "<b>Reason:</b>" + activitySet.getCommentForHistory(issue) +"<br/>";
            
            entry.setAuthor(activitySet.getCreator().getName());

            description.setValue(desc.toString());            

			String entryTitle = createEntryTitle(activity);
            entry.setTitle(entryTitle);
            
            entry.setDescription(description);
            
            //The hashCode is a cheap trick to have a unique link tag in the RSS feed
            //to help those reader as ThunderBird that use the link to check for new items
            entry.setLink(link+"?hash="+entry.hashCode());
            
            entries.add(entry);
        }
     

        feed.setEntries(entries);
        
        return feed;
    }
            
// in java/org/tigris/scarab/feeds/QueryFeed.java
public SyndFeed getFeed() throws Exception, TorqueException, DataSetException, TurbineSecurityException
    {
        SyndFeed feed = new SyndFeedImpl();
        feed.setTitle(query.getName());
        String link = scarabLink.setAction("Search").addPathInfo("go",query.getQueryId()).toString();
        feed.setLink(link);
        feed.setDescription(query.getDescription());
        List entries = new ArrayList();
        for(Iterator i = results.iterator(); i.hasNext();)
        {
            SyndEntry entry = new SyndEntryImpl();
            SyndContent description = new SyndContentImpl();
            QueryResult queryResult = (QueryResult)i.next();
            String title = queryResult.getUniqueId();
            entry.setTitle(title);
            
            Issue issue = IssueManager.getInstance(Long.valueOf(queryResult.getIssueId()));

            link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
            entry.setLink(link);

            Date publishedDate = null;
            if(issue.getModifiedDate()!= null){
                publishedDate = issue.getModifiedDate();
            }
            else {
                publishedDate = issue.getCreatedDate();
            }
            entry.setPublishedDate(publishedDate);

            description = new SyndContentImpl();
            description.setType("text/html");
            String desc = "";
            Iterator avIteratorCSV = queryResult.getAttributeValuesAsCSV().iterator();
            Iterator avIterator = query.getMITList().getAllRModuleUserAttributes().iterator();
            while (avIterator.hasNext())
            {
                String value = (String)avIteratorCSV.next();
                RModuleUserAttribute av = (RModuleUserAttribute)avIterator.next();
                desc = desc + "<b>" + av.getAttribute().getName()+":</b>" + value +"<br/>";
            }
            description.setValue(ScarabUtil.filterNonXml(desc));

            entry.setDescription(description);
            entries.add(entry);
        }
        feed.setEntries(entries);
        feed.setFeedType(format);
        return feed;
    }
            
// in java/org/tigris/scarab/components/TorqueComponent.java
public void initialize()
            throws Exception
    {
        getLogger().debug("initialize()");
        Torque.init(
            Turbine.getConfiguration()
        );
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        String next = ScarabUtil.findValue(data, "next");
        if (StringUtils.isNotEmpty
            (ScarabUtil.findValue(data, ExportFormat.KEY_NAME)))
        {
            // Send to the IssueListExport screen (which actually
            // has no corresponding Velocity template).
            setTarget(data, "IssueListExport.vm");
        }
        else if (StringUtils.isNotEmpty(next))
        {
            // Redirect to View, Assign, or Move/Copy
            List issueIds = null;
            ScarabUser user = (ScarabUser) data.getUser();
            if (next.indexOf("All") > -1)
            {
                // all issues are selected
                issueIds = getAllIssueIds(data);
            }
            else
            {
                // get issues select by user
                issueIds = getSelected(data);
            }


            if (issueIds.size() < 1)
            {
                scarabR.setAlertMessage(L10NKeySet.SelectIssues);
                return;
            }

            List modules = ModuleManager.getInstancesFromIssueList(
                scarabR.getIssues(issueIds));
            if (next.indexOf("assign") > -1)
            {
                if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, modules))
                {
                    if (issueIds.size() <= ScarabConstants.ISSUE_MAX_ASSIGN)
                    {
                        scarabR.resetAssociatedUsers();
                        setTarget(data, "AssignIssue.vm");
                    }
                    else
                    {
                        L10NMessage msg = new L10NMessage
                        (
                            L10NKeySet.IssueLimitExceeded,
                            String.valueOf(ScarabConstants.ISSUE_MAX_ASSIGN)
                        );
                        scarabR.setAlertMessage(msg);
                        return;
                    }
                }
                else
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                    return;
                }
            }
            else if (next.indexOf("view") > -1)
            {
                if (user.hasPermission(ScarabSecurity.ISSUE__VIEW, modules))
                {
                    if (issueIds.size() <= ScarabConstants.ISSUE_MAX_VIEW)
                    {
                        setTarget(data, "ViewIssueLong.vm");
                    }
                    else
                    {
                        L10NMessage msg = new L10NMessage
                        (
                            L10NKeySet.IssueLimitExceeded,
                            String.valueOf(ScarabConstants.ISSUE_MAX_VIEW)
                        );
                        scarabR.setAlertMessage(msg);
                        return;
                    }
                }
                else
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                    return;
                }
            }
            else if (next.indexOf("copy") > -1)
            {
                if (user.hasPermission(ScarabSecurity.ISSUE__ENTER, modules))
                {
                    if (issueIds.size() <= ScarabConstants.ISSUE_MAX_COPY)
                    {
                        data.getParameters().add("mv_0rb", "copy");
                        setTarget(data, "MoveIssue.vm");
                    }
                    else
                    {
                        L10NMessage msg = new L10NMessage
                        (
                            L10NKeySet.IssueLimitExceeded,
                            String.valueOf(ScarabConstants.ISSUE_MAX_COPY)
                        );
                        scarabR.setAlertMessage(msg);
                        return;
                    }
                }
                else
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
            }
            else if (next.indexOf("move") > -1)
            {
                if (user.hasPermission(ScarabSecurity.ISSUE__MOVE, modules))
                {
                    if (issueIds.size() <= ScarabConstants.ISSUE_MAX_MOVE)
                    {
                        data.getParameters().add("mv_0rb", "move");
                        setTarget(data, "MoveIssue.vm");
                    }
                    else
                    {
                        L10NMessage msg = new L10NMessage
                        (
                            L10NKeySet.IssueLimitExceeded,
                            String.valueOf(ScarabConstants.ISSUE_MAX_MOVE)
                        );
                        scarabR.setAlertMessage(msg);
                        return;
                    }
                }
                else
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
            }
        }
        else
        {
            String template = data.getParameters()
                .getString(ScarabConstants.NEXT_TEMPLATE,
                           getIssueListTarget());
            setTarget(data, template);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doSearch(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        String queryString = getQueryString(data);        
        setRecentQuery(queryString);
        translateSortorder(data, queryString);

        doPerform(data, context);
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doRedirecttosavequery(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data, context);
        if (data.getParameters().getString("refine") != null)
        {
            setRecentQuery(getQueryString(data));
        }

        if (scarabR.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES))
        {
            setTarget(data, "SaveQuery.vm");
        }
        else 
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doRedirecttocrossmodulelist(RunData data, TemplateContext context)
         throws Exception
    {
        data.getParameters().setString("queryString", getQueryString(data));
        setTarget(data, "IssueTypeList.vm");
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doSavequery(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data, context);
        
        if (!scarabR.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

               
        Module module = scarabR.getCurrentModule();
        Query query = scarabR.getQuery();
        Group queryGroup = intake.get("Query",
                                      query.getQueryKey());

        Field name = queryGroup.get("Name");
        name.setRequired(true);
        data.getParameters().setString("queryString", getQueryString(data));

        if (intake.isAllValid())
        {
            queryGroup.setProperties(query);
            query.setScarabUser(user);
            MITList currentList = user.getCurrentMITList();
            if (currentList == null)
            {
                scarabR.setAlertMessage(L10NKeySet.NoIssueTypeList);
                return;
            }
            else
            {
                //
                // Get hold of all the attributes that apply to
                // this list. We will have to copy them manually
                // to the new list because MITList.copy() won't
                // do it for us.
                //
                List commonAttributes = 
                    currentList.getCommonRModuleUserAttributes();
                
                // associate the query with a new list, the current
                // implementation does not allow for multiple queries to
                // work from the same MITList and this guarantees they
                // will not accidently be linked.
                currentList = currentList.copy();
                if (currentList.isModifiable())
                {
                    currentList.setName(null);
                }
                
                //
                // Copy the attributes from the original list
                // to the new one.
                //
                for (Iterator iter = commonAttributes.iterator();
                              iter.hasNext(); )
                {
                    RModuleUserAttribute attr =
                            (RModuleUserAttribute) iter.next();
                    
                    //
                    // When we copy the attribute, we don't actually
                    // want to keep the list ID because that refers
                    // to the old list rather than the new one. So
                    // we just clear it - when the list is saved the
                    // correct list ID will automatically be set for
                    // the attribute.
                    //
                    RModuleUserAttribute newAttr = attr.copy();
                    newAttr.setListId(null);
                    newAttr.setUserId(user.getUserId());
                    currentList.addRModuleUserAttribute(newAttr);
                }
                
                //
                // Update the query to use the new MIT list.
                //
                query.setMITList(currentList);
                if (!currentList.isSingleModule())
                {
                    query.setModule(null);
                    query.setScopeId(Scope.PERSONAL__PK);
                }
            }

            ScarabUser[] userList =
                module.getUsers(ScarabSecurity.ITEM__APPROVE);
            if (checkForDupes(query, user, module))
            {
                scarabR.setAlertMessage(L10NKeySet.DuplicateQueryName);
            }
            else if (Scope.MODULE__PK.equals(query.getScopeId())
                 && user.hasPermission(ScarabSecurity.ITEM__APPROVE, module)
                 && (userList == null || userList.length == 0))
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.NoApproverAvailable, module.getName());
                scarabR.setAlertMessage(msg);
            }
            else
            {
                try
                {
                    query.saveAndSendEmail(user, module, context);
                }
                catch(Exception e)
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneral,e);
                    scarabR.setAlertMessage(msg);
                }
                scarabR.resetSelectedUsers();
                if (query.canEdit(user))
                {
                    scarabR.setConfirmMessage(DEFAULT_MSG);
                }
                else
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.NotifyPendingApproval,L10NKeySet.Query);
                    scarabR.setInfoMessage(msg);
                    //scarabR.setInfoMessage(
                    //        l10n.format("NotifyPendingApproval",
                    //        l10n.get("Query").toLowerCase()));
                }
                setTarget(data, "QueryList.vm");
            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public boolean doEditqueryinfo(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        boolean success = false;

        Module module = scarabR.getCurrentModule();
        Query query = scarabR.getQuery();
        Group queryGroup = intake.get("Query",
                                      query.getQueryKey());
        queryGroup.get("Name").setRequired(true);
        if (intake.isAllValid())
        {
            queryGroup.setProperties(query);
            if (checkForDupes(query, user, module))
            {
                scarabR.setAlertMessage(L10NKeySet.DuplicateQueryName);
            }
            else
            {
                query.saveAndSendEmail(user, module, context);
                success = true;
                if (query.canEdit(user))
                {
                    scarabR.setConfirmMessage(L10NKeySet.QueryModified);
                }
                else
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.NotifyPendingApproval,L10NKeySet.Query);
                    scarabR.setInfoMessage(msg);
                    //scarabR.setInfoMessage(
                    //                l10n.format("NotifyPendingApproval",
                    //                l10n.get("Query").toLowerCase()));
                    setTarget(data, data.getParameters().getString(
                                    ScarabConstants.CANCEL_TEMPLATE));
                }

            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doPreparequery(RunData data, TemplateContext context)
         throws Exception
    {        
        setup(data, context);
        Query query = scarabR.getQuery();
        user.setCurrentMITList(query.getMITList());
        /* TODO! It would be better if the query could be viewed or
           edited without having to pass the query data via request parameters
           as would be done with the code below, but it caused a few bugs like
           losing users and maybe the mitlist, so revisit this later.
        user.setMostRecentQuery(query.getValue());
        */
        setRecentQuery(getQueryString(data));
        scarabR.resetSelectedUsers();
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doEditstoredquery(RunData data, TemplateContext context)
         throws Exception
    {        
        setup(data, context);        

        Query query = scarabR.getQuery();
        String newValue = getQueryString(data);
        query.setValue(newValue);
        query.saveAndSendEmail((ScarabUser)data.getUser(), 
                 scarabR.getCurrentModule(), context);
        scarabR.resetSelectedUsers();
        setRecentQuery(newValue);
    }
            
// in java/org/tigris/scarab/actions/Search.java
private void doRunstoredquery(RunData data, TemplateContext context)
         throws Exception
    {
        //setup(data, context);
        // Set current query to the stored query
        Query query = scarabR.getQuery();
        MITList mitList = query.getMITList();
        user.setCurrentMITList(mitList);
        if (mitList != null)
        {
            mitList.setScarabUser(user);
        }
        setRecentQuery(query.getValue());
        
        translateSortorder(data, query.getValue());

        setTarget(data, getIssueListTarget());
    }
            
// in java/org/tigris/scarab/actions/Search.java
private void translateSortorder(RunData data, String queryString) throws Exception
    {
        // Add 'sortColumn', 'sortPolarity' and 'resultsPerPage'
        // to the RunData parameters. This ensures that when the
        // user runs a saved query, the resulting issue list is
        // displayed with that query's settings. 
        //
        // TODO remove translateSortorder
        // this method is just a hack
        // instead of translating between different parameter names
        // the sortorder-parameter should have the same name, 
        // in the edit-query-screens as well as in the issue list
        StringValueParser parser = ScarabUtil.parseURL(queryString);
        
        if (parser.containsKey("resultsperpage")) {
            data.getParameters().add("resultsperpage",
                                     parser.getInt("resultsperpage"));
        }
        
        if (parser.containsKey("searchsai")) {
            data.getParameters().add("sortColumn",
                                     parser.getInt("searchsai"));
        }
        
        if (parser.containsKey("searchsp")) {
            data.getParameters().add("sortPolarity",
                                     parser.getString("searchsp"));
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doSelectquery(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        String go = data.getParameters().getString("go");
        

        if (go != null && go.length() > 0)
        {
            // if the string is a number, then execute
            // doRunstoredquery()
            if (StringUtils.isNumeric(go))
            {
                data.getParameters().setString("queryId", go);
                doRunstoredquery(data, context);
            }
            else if (go.startsWith("newQuery"))
            {
                // do this to load last mitlist
                user.getMostRecentQuery();
                if (go.endsWith("IT")) 
                {
                    user.setCurrentMITList(null);
                }
                // reset selected users map
                scarabR.resetSelectedUsers();                
                setTarget(data, user.getQueryTarget());
            }
            else if (go.equals("mostRecent"))
            {
                setTarget(data, getIssueListTarget());
            }
            else if (go.equals("myIssuesThisModule"))
            {
                Module module = user.getCurrentModule();
                user.setCurrentMITList(MITListManager
                    .getSingleModuleAllIssueTypesList(module, user));

                String userId = user.getQueryKey();
                StringBuffer sb = new StringBuffer(26 + 2*userId.length());
                String query = sb.append("&user_list=").append(userId)
                    .append("&user_attr_").append(userId).append("=any")
                    .toString();
                setRecentQuery(query);
                setTarget(data, getIssueListTarget());
            }
            else if (go.equals("myIssuesAllModules"))
            {
                user.setCurrentMITList(MITListManager.getAllModulesAllIssueTypesList(user));

                String userId = user.getQueryKey();
                StringBuffer sb = new StringBuffer(26 + 2*userId.length());
                String query = sb.append("&user_list=").append(userId)
                    .append("&user_attr_").append(userId).append("=any")
                    .toString();
                setRecentQuery(query);
                setTarget(data, getIssueListTarget());
            }
            else if (go.equals("quickSearch"))
            {
                String searchString = data.getParameters().getString("searchString");
                if(searchString==null || searchString.equals(""))
                {
                    scarabR.setAlertMessage(L10NKeySet.QueryParserError);
                }
                else
                {
                    Module module = user.getCurrentModule();
                    MITList mitList = MITListManager.getSingleModuleAllIssueTypesList(module,user);
                    user.setCurrentMITList(mitList); 
                               
                    Map attributeMap = new Hashtable();
                    List attributes = module.getAllAttributes();
                    for( int aindex = 0; aindex < attributes.size(); aindex++)
                    {
                        Attribute attribute = (Attribute) attributes.get(aindex);
                        AttributeType type = attribute.getAttributeType();
                        String typeName = type.getName();
                        if(typeName.equals("string") || typeName.equals("long-string"))
                        {
                            if (attribute.isTextAttribute())
                            {
                                Integer id = attribute.getAttributeId();
                                if(attributeMap.get(id) == null)
                                {
                                    attributeMap.put(id,attribute);
                                }
                            }
                        }
                    }
                    quickSearch(searchString, attributeMap, user);
                }
                setTarget(data, getIssueListTarget());
            }
            else if (go.equals("privateQueries")
                   ||go.equals("publicQueries"))
            {
                setTarget(data,"QueryList.vm");
            }
            else
            {
                setTarget(data, go);
            }
        }
        else
        {
            // set the next template
            String nextTemplate = data.getParameters()
                .getString(ScarabConstants.NEXT_TEMPLATE, 
                Turbine.getConfiguration()
                           .getString("template.homepage", "Index.vm"));
            setTarget(data, nextTemplate);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doRefinequery(RunData data, TemplateContext context)
         throws Exception
    {        
        context.put("refine", "true");
        setTarget(data, "AdvancedQuery.vm");    
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = doEditqueryinfo(data, context);
        if (success)
        {
            doEditstoredquery(data, context);
            doCancel(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public static String getQueryString(RunData data) throws Exception
    {
        String queryString = data.getParameters().getString("queryString");
        if (queryString == null) 
        {
            StringBuffer buf = new StringBuffer();
            Object[] keys =  data.getParameters().getKeys();
            for (int i =0; i<keys.length; i++)
            {
                String key = keys[i].toString();
                if (key.startsWith("attv") || key.startsWith("search")
                    || key.startsWith("intake") || key.startsWith("user_attr")
                    || key.startsWith("user_list") || key.startsWith("results")
                    || "format".equalsIgnoreCase(key))
                {
                    String[] values = data.getParameters().getStrings(key);
                    for (int j=0; j<values.length; j++)
                    {
                        String value = values[j];
                        if (StringUtils.isNotEmpty(value))
                        {
                            buf.append('&').append(key);
                            buf.append('=').append(ScarabUtil.urlEncode(value));
                        }
                    }
                }
            }

            queryString = (buf.length() == 0
                           ? ((ScarabUser)data.getUser()).getMostRecentQuery()
                           : buf.toString());
        }
        if(queryString == null)
        {
            queryString="";
        }
        return queryString.toLowerCase();
    }
            
// in java/org/tigris/scarab/actions/Search.java
private boolean checkForDupes(Query query, ScarabUser user, Module module)
        throws Exception
    {
        boolean areThereDupes = false;
        List prevQueries = new ArrayList();
        if (query.getScopeId().equals(Scope.MODULE__PK))
        {
            prevQueries.addAll(QueryPeer.getModuleQueries(module));
        }
        else
        {
            // Add personal queries only, not all module-level queries created
            // by this user.
            for (Iterator i = QueryPeer.getUserQueries(user).iterator(); i.hasNext(); ) 
            {
                Query q = (Query)i.next();
                if (q.getModule() == null)
                {
                    prevQueries.add(q);
                }
            }
        }
        if (prevQueries != null && !prevQueries.isEmpty())
        {
            Long pk = query.getQueryId();
            String name = query.getName();
            for (Iterator i = prevQueries.iterator(); 
                 i.hasNext() && !areThereDupes;)
            {
                Query q = (Query)i.next();
                areThereDupes = (pk == null || !pk.equals(q.getQueryId())) &&
                    name.trim().toLowerCase().equals(
                        q.getName().trim().toLowerCase());
            }
        }
        return areThereDupes;
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doGotoeditlist(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        Map userMap = user.getSelectedUsersMap();
        if (userMap == null || userMap.size() == 0)
        {
            userMap = new HashMap();
            loadUsersFromUserList(data, userMap);
        }
        data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE,
                                       getCurrentTemplate(data));
        setRecentQuery(getQueryString(data));
        IssueSearch search = scarabR.getPopulatedSearch();
        if (search != null)
        {
            setTarget(data, "UserList.vm");
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doAddusers(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data, context);
        
        Map userMap = user.getSelectedUsersMap();
        if (userMap == null)
        {
            userMap = new HashMap();
        }        
        String[] userIds = params.getStrings(ADD_USER);
        if (userIds != null && userIds.length > 0) 
        {
            for (int i =0; i<userIds.length; i++)
            {
                String userId = userIds[i];
                String[] attrIds = params.getStrings("user_attr_" + userId);
                if (attrIds != null) 
                {
                    for (int j=0; j<attrIds.length; j++) 
                    {
                        addAttributeToMap(userMap, userId, attrIds[j], context);
                    }
                }
            } 
            user.setSelectedUsersMap(userMap);
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereAdded);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doAdduserbyusername(RunData data, TemplateContext context)  
        throws Exception
    {
        setup(data, context);

        String userName = params.getString(ADD_USER_BY_USERNAME);
        String attrId = params.getString("add_user_attr");

        Map userMap = user.getSelectedUsersMap();
        if (userMap == null || userMap.size() == 0)
        {
            userMap = new HashMap();
            loadUsersFromUserList(data, userMap);
        }

        String userId = null;
       
        if(IssueSearch.SEARCHING_USER_KEY.equalsIgnoreCase(userName))
        {
            userId=userName;
        }
        else
        {
            ScarabUser newUser = scarabR.getUserByUserName(userName);        
            if (newUser != null)
            {
                userId = newUser.getUserId().toString();
            }
        }
    
        if (userId!=null)
        {
            addAttributeToMap(userMap, userId, attrId, context);
            user.setSelectedUsersMap(userMap);
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereAdded);
        }
        else
        {
            scarabR.setAlertMessage(L10NKeySet.UserNotPossibleAssignee);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doRemoveusers(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
         
        Map userMap = user.getSelectedUsersMap();
        if (userMap == null || userMap.size() == 0)
        {
            userMap = new HashMap();
            loadUsersFromUserList(data, userMap);
        }
        
        String[] userAttrIds =  params.getStrings(SELECTED_USER);
        if (userAttrIds != null && userAttrIds.length > 0) 
        {
            for (int i =0; i<userAttrIds.length; i++)
            {
                String userAttrId = userAttrIds[i];
                int delimPos = userAttrId.indexOf('_');
                String userId = userAttrId.substring(0, delimPos);
                Set currentAttrIds = (Set)userMap.get(userId);
                if (currentAttrIds.size() == 1) 
                {
                    userMap.remove(userId);                    
                }
                else 
                {
                    currentAttrIds.remove(userAttrId.substring(delimPos+1));
                }
            }
            user.setSelectedUsersMap(userMap);
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereRemoved);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doUpdateusers(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        
        Map userMap = user.getSelectedUsersMap();
        
        String[] userAttrIds =  params.getStrings(SELECTED_USER);
        if (userAttrIds != null && userAttrIds.length > 0) 
        {
            for (int i =0; i<userAttrIds.length; i++)
            {
                String userAttrId = userAttrIds[i];
                int delimPos = userAttrId.indexOf('_');
                String userId = userAttrId.substring(0, delimPos);
                String oldAttrId = userAttrId.substring(delimPos+1);
                String newAttrId = params
                    .getString("user_attr_" + userAttrId);
                if (!oldAttrId.equals(newAttrId)) 
                {
                    List currentAttrIds = (List)userMap.get(userId);
                    if (ANY.equals(newAttrId)) 
                    {
                        currentAttrIds.clear();
                        currentAttrIds.add(ANY);
                    }
                    else 
                    {
                        for (int j=currentAttrIds.size()-1; j>=0; j--) 
                        {
                            if (currentAttrIds.get(j).equals(oldAttrId)) 
                            {
                                currentAttrIds.set(j, newAttrId);
                                break;
                            }
                        }
                    }
                }                
            }
            user.setSelectedUsersMap(userMap);
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereModified);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void loadUsersFromUserList(RunData data, Map userMap)
        throws Exception
    {
        ParameterParser params = data.getParameters();
        String[] userList = params.getStrings(USER_LIST);
        if (userList !=null && userList.length > 0)
        {
            for (int i =0;i<userList.length;i++)
            {
                String userId = userList[i];
                String[] attrIds = params.getStrings("user_attr_" + userId);
                if (attrIds != null) 
                {
                    for (int j=0; j<attrIds.length; j++) 
                    {
                        addAttributeToMap(userMap, userId, attrIds[j],
                                          getTemplateContext(data));
                    }
                }
            }
            ((ScarabUser)data.getUser()).setSelectedUsersMap(userMap);
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doSetquerytarget(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data, context);
        
        MITList mitlist = user.getCurrentMITList();
        if (mitlist != null && mitlist.isSingleModuleIssueType()) 
        {
            user.setSingleIssueTypeQueryTarget(
                mitlist.getIssueType(), data.getTarget());
        }
        else 
        {
        
            if (mitlist == null) 
            {
                scarabR.setAlertMessage(L10NKeySet.NoIssueTypeList);
            }
            else 
            {
                scarabR.setAlertMessage(L10NKeySet.IssueTypeListMoreThanOne);
            }
            

            Log.get().warn(
                "Issue type list did not contain one and only one element.");
        }
    }
            
// in java/org/tigris/scarab/actions/Search.java
private void setup(RunData data, TemplateContext context) throws Exception{
        l10n = getLocalizationTool(context);
        scarabR = getScarabRequestTool(context);
        intake = getIntakeTool(context);
        params = data.getParameters();
        user = (ScarabUser)data.getUser();
    }
            
// in java/org/tigris/scarab/actions/ForgotPassword.java
public void doForgotpassword(RunData data, TemplateContext context)
        throws Exception
    {
        data.setACL(null);
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid() && forgotPassword(data, context))
        {
            setTarget(data, "Login.vm");
        }
    }
            
// in java/org/tigris/scarab/actions/ForgotPassword.java
public boolean forgotPassword(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        
        Group password = intake.get("ForgotPassword", IntakeTool.DEFAULT_KEY);
        String username = password.get("Username").toString();
        
        ScarabUser user = null;
        try
        {
            user = ScarabUserManager.getInstance(username);
            
            String tempPassword = PasswordGenerator.generate();
            
            // first we need to save the user out of the session
            user.setPasswordExpire(Calendar.getInstance());
            user.setHasLoggedIn(Boolean.FALSE);
            data.setUser(user);
            data.save();

            // set the password to a temporary value then set the password to
            // expire now, forcing the user to change their password after login.
            TurbineSecurity.forcePassword(user, tempPassword);

            sendNotificationEmail(context, user, tempPassword);
            
            // create confirmation message
            Localizable msg = new L10NMessage(L10NKeySet.PasswordResetMessage,
                                              user.getEmail()); 
            getScarabRequestTool(context).setConfirmMessage(msg);
        }
        catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
        return true;
    }
            
// in java/org/tigris/scarab/actions/ForgotPassword.java
public static void sendNotificationEmail(TemplateContext context, ScarabUser user, String tempPassword) throws Exception
    {
        // place the password
        // in the context for use in the email template.
        context.put("password", tempPassword);

        Email te = new Email();
        
        // Retrieve the charset to be used for the Email.
        ScarabLocalizationTool l10n = (new ForgotPassword()).getLocalizationTool(context);
        Locale locale = l10n.getPrimaryLocale();
        String charset = Email.getCharset(locale);
        te.setCharset(charset);
        
        
        te.setContext(new ContextAdapter(context));
        te.addTo(user.getEmail(), user.getFirstName() + " " + user.getLastName());
        te.setFrom(
            Turbine.getConfiguration()
                .getString("scarab.email.forgotpassword.fromAddress",
                           "help@localhost"),
            Turbine.getConfiguration()
                .getString("scarab.email.forgotpassword.fromName",
                           "Scarab System"));
        te.setSubject(
            l10n.get(L10NKeySet.ForgotPasswordEmailSubject));
        te.setTemplate(
            Turbine.getConfiguration()
                .getString("scarab.email.forgotpassword.template",
                           "email/ForgotPassword.vm"));
        te.send();
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
private void setup(RunData data, TemplateContext context) throws Exception{
        l10n = getLocalizationTool(context);
        scarabR = getScarabRequestTool(context);
        report = scarabR.getReport();
        intake = getIntakeTool(context);
        params = data.getParameters();
        user = (ScarabUser)data.getUser();
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSaveinfo(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable((ScarabUser)data.getUser())) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");                        
        }
        else if (intake.isAllValid()) 
        {
            Group intakeReport = getIntakeReportGroup(intake, report);
            if (intakeReport != null) 
            {   
                intakeReport.setValidProperties(report);

                if (report.isReadyForCalculation()) 
                {
                    String msg = report.isNew() ? 
                           l10n.get(L10NKeySet.ReportUpdated) :
                           l10n.get(L10NKeySet.ReportUpdatedNotSaved);
                    scarabR.setConfirmMessage(msg);
                    setTarget(data, "reports,Info.vm");     
                }
                else 
                {
                    String msg = report.isNew() ? 
                           l10n.get("ReportUpdatedPleaseAddRowAndColumnCriteria") :
                           l10n.get("ReportUpdatedNotSavedPleaseAddRowAndColumnCriteria");
                    scarabR.setConfirmMessage(msg);
                    setTarget(data, "reports,AxisConfiguration.vm");
                }
            }
            else 
            {
                // FIXME! i don't know that the intakeReport should ever be 
                // null, but since the conditional was here, don't fail silently
                scarabR.setAlertMessage(
                		L10NKeySet.ThisShouldNotHappenPleaseContactAdmin);
                setTarget(data, "reports,Info.vm");
            }            
        }
        else 
        {
            scarabR.setAlertMessage(
            		L10NKeySet.InvalidData);
            setTarget(data, "reports,Info.vm");            
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSelectheading(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        // the form will carry over the selected heading. just make sure
        // to remove old intake data
        
        intake.removeAll();
        // give the user a message if they are already on the selected
        // heading, in the event they are confused.
        
        int level = params.getInt("heading", -1);
        int prevLevel = params.getInt("prevheading", -2);
        if (level == prevLevel) 
        {
            getScarabRequestTool(context).setInfoMessage(
                getLocalizationTool(context)
                .format("AlreadyEditingSelectedHeading", new Integer(level+1)));
        }        
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSettype(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        int type = params.getInt("headingtype", 0);

        // remove any old data
        if (level != -1) 
        {
            
            ReportDefinition reportDefn = report.getReportDefinition();
            ReportAxis reportAxis = reportDefn.getAxis(axis);
            ReportHeading heading = reportAxis.getHeading(level);
            int currentType = heading.calculateType();
            if (type != currentType) 
            {            
                if (currentType == 2 && 
                    !reportDefn.allowMoreHeadings(reportAxis)) 
                {
                    scarabR.setAlertMessage(L10NKeySet.ThisAxisMustBeDatesUnlessHeadingsAreRemoved);
                    params.setString("headingtype", "2");
                }
                else 
                {
                    LocalizationKey msg;
                    if (heading.size() > 0) 
                    {
                        heading.reset();
                        msg = L10NKeySet.HeadingTypeChangedOldDataDiscarded;
                    }
                    else
                    {
                        msg = L10NKeySet.HeadingTypeChanged;
                    }
                    scarabR.setConfirmMessage(msg);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAddoptions(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable((ScarabUser)data.getUser())) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");                        
        }
        else if (intake.isAllValid()) 
        {


            int axis = params.getInt("axis", 0); // 0=row; 1=column
            int level = params.getInt("heading", -1);
            int type = params.getInt("headingtype", 0);

            // we are using an IssueSearch object to gather the data to
            // create the ReportOptionAttribute objects.
            IssueSearch search = scarabR.getNewSearch();

            // Set attribute values to search on
            for (Iterator i = search.getAttributeValuesMap(true).values().iterator(); i.hasNext();) 
            {
                AttributeValue aval = (AttributeValue)i.next();
                Group group = intake.get("AttributeValue", aval.getQueryKey());
                if (group != null) 
                {
                    group.setProperties(aval);
                }                
            }
            
            List setAttValues = search.getSetAttributeValues();
            
            ReportHeading heading = report.getReportDefinition()
                .getAxis(axis).getHeading(level);
            if (type != heading.calculateType()) 
            {
                scarabR.setAlertMessage(L10NKeySet.ChangeOfTypeMessage); 
            }
    
            // we are going to delete the old heading data and reconstruct it
            // so if there is any group info, we need to get it first
            List groups = heading.getReportGroups();
            Map optionGroupMap = null;
            if (groups != null && !groups.isEmpty()) 
            {
                optionGroupMap = new HashMap();
                for (Iterator i = groups.iterator(); i.hasNext();) 
                {
                    ReportGroup group = (ReportGroup)i.next();
                    List options = group.getReportOptionAttributes();
                    if (options != null && !options.isEmpty()) 
                    {
                        for (Iterator j = options.iterator(); j.hasNext();) 
                        {
                            optionGroupMap.put(j.next(), group);
                        }
                    }
                }
            }
            heading.reset();
            
            //convert to ReportOptionAttributes
            for (Iterator i = setAttValues.iterator(); i.hasNext();) 
            {
                AttributeValue av = (AttributeValue)i.next();
                //pull any chained values out to create a flat list
                List chainedValues = av.getValueList();
                for (Iterator j = chainedValues.iterator(); j.hasNext();) 
                {
                    ReportOptionAttribute roa = new ReportOptionAttribute();
                    Integer id = Integer.valueOf(((AttributeValue)j.next())
                                             .getOptionId().toString());
                    roa.setOptionId(id);
    
                    if (optionGroupMap == null) 
                    {
                        heading.addReportOptionAttribute(roa);
                    }
                    else 
                    {
                        ReportGroup group = 
                            (ReportGroup)optionGroupMap.get(roa);
                        if (group == null)
                        {
                            // add it to the first group
                            ((ReportGroup)groups.get(0))
                                .addReportOptionAttribute(roa);
                        }
                        else
                        {
                            group.addReportOptionAttribute(roa);
                        }
                    }
                }
            }
            if (level == -1) 
            {
                params.setString("heading", "0");
            }
    
            String msg = getLocalizedHeadingConfirmMessage(report, l10n);
            scarabR.setConfirmMessage(msg);
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAddusers(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }


        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        int type = params.getInt("headingtype", 0);
        
        // not too elegant for editing, but if groups have been defined
        // we remove them for now until the rest of the reports is 
        // more code complete !FIXME!
        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        if (type != heading.calculateType() 
            || heading.getReportGroups() != null) 
        {
            if (heading.getReportGroups() != null) 
            {
               scarabR.setAlertMessage(L10NKeySet.CouldNotMakeRequestedChange);                
            }
            heading.reset();
        }

        String[] userIds = params.getStrings(ADD_USER);
        if (userIds != null && userIds.length > 0) 
        {
            for (int i =0; i<userIds.length; i++)
            {
                String userId = userIds[i];
                ReportUserAttribute rua = new ReportUserAttribute();
                rua.setUserId(new Integer(userId));
                rua.setAttributeId(new Integer(
                    params.getString("user_attr_" + userId)));
                heading.addReportUserAttribute(rua);
            } 
            if (level == -1) 
            {
                params.setString("heading", "0");
            }

            String msg = getLocalizedHeadingConfirmMessage(report, l10n);
            scarabR.setConfirmMessage(msg);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doRemoveusers(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        int type = params.getInt("headingtype", 0);
        
        // not too elegant for editing, but if groups have been defined
        // we remove them for now until the rest of the reports is 
        // more code complete !FIXME!
        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        if (type != heading.calculateType() 
            || heading.getReportGroups() != null) 
        {
            heading.reset();
            scarabR.setAlertMessage(L10NKeySet.CouldNotMakeRequestedChange);                
        }
        else 
        {
            String[] userIds =  params.getStrings(SELECTED_USER);
            if (userIds != null && userIds.length > 0) 
            {
                for (int i =0; i<userIds.length; i++)
                {
                    String userId = userIds[i];
                    ReportUserAttribute rua = new ReportUserAttribute();
                    rua.setUserId(new Integer(userId));
                    rua.setAttributeId(new Integer(
                        params.getString("old_attr_" + userId)));
                    
                    List ruas =  heading.getReportUserAttributes();
                    if (ruas != null) 
                    {
                        ruas.remove(rua);
                    }
                }
                scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereRemoved);
            }
            else 
            {
                scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
            }
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doUpdateusers(RunData data, TemplateContext context) 
        throws Exception
    {
        
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        int type = params.getInt("headingtype", 0);
        
        // not too elegant for editing, but if groups have been defined
        // we remove them for now until the rest of the reports is 
        // more code complete !FIXME!
        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        if (type != heading.calculateType() 
            || heading.getReportGroups() != null) 
        {
            heading.reset();
            scarabR.setAlertMessage(L10NKeySet.CouldNotMakeRequestedChange);
        }
        else 
        {
            String[] userIds =  params.getStrings(SELECTED_USER);
            if (userIds != null && userIds.length > 0) 
            {
                for (int i =0; i<userIds.length; i++)
                {
                    String userId = userIds[i];
                    ReportUserAttribute rua = new ReportUserAttribute();
                    rua.setUserId(new Integer(userId));
                    rua.setAttributeId(new Integer(
                        params.getString("old_attr_" + userId)));
                    
                    List ruas =  heading.getReportUserAttributes();
                    if (ruas != null) 
                    {
                        /* this will make it hard to find dupes
                        for (Iterator i=ruas.iterator(); i.hasNext();) 
                        {
                            Object obj = i.next();
                            if (obj.equals(rua)) 
                            {
                                ((ReportUserAttribute)obj).setAttributeId();
                            }
                        }
                        */
                        ruas.remove(rua);
                    }
                    
                    rua = new ReportUserAttribute();
                    rua.setUserId(new Integer(userId));
                    rua.setAttributeId(new Integer(
                        params.getString("asso_user_{" + userId + "}")));
                    heading.addReportUserAttribute(rua);
                }
                scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereModified);
            }
            else 
            {
                scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
            }
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doRemoveheading(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        //int type = params.getInt("headingtype", 0);
        
        if (level >= 0) 
        {
            List headings = report.getReportDefinition()
                .getAxis(axis).getReportHeadings();
            headings.remove(level);
            scarabR.setConfirmMessage(L10NKeySet.HeadingRemoved); 
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoHeadingSelected);     
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doGotoeditgroups(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        
        int level = params.getInt("heading", -1);

        // user groups is not implemented
        if (level >= 0) 
        {
            int axis = params.getInt("axis", 0); // 0=row; 1=column        
            ReportHeading heading = (ReportHeading)report.getReportDefinition()
                .getAxis(axis).getReportHeadings().get(level);
            if (heading.calculateType() == 0) 
            {
                setTarget(data, "reports,EditGroups.vm");
            }
            else 
            {
                scarabR.setAlertMessage(getLocalizationTool(context)
                    .get("GroupsAreForOptionsOnly"));
            }
        }
        else
        {
            scarabR.setAlertMessage(L10NKeySet.NoHeadingSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAddheading(RunData data, TemplateContext context) 
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }


        int axisIndex = params.getInt("axis", 0); // 0=row; 1=column
        ReportAxis axis = report.getReportDefinition().getAxis(axisIndex);
        axis.addReportHeading(new ReportHeading());
        params.setString("heading", String.valueOf(axis.getReportHeadings().size()-1));
        // remove old intake data
        Intake intake = getIntakeTool(context);
        intake.removeAll();
        scarabR.setConfirmMessage(L10NKeySet.HeadingAddedNowAddContent);
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAddgroup(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
                    
        String name = params.getString("groupname_new");
        if (name != null)
        {
            name = name.trim();
        }

        if (name == null || name.length() == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.InvalidGroupName);
        }
        else
        {
            ReportHeading heading = report.getReportDefinition()
                .getAxis(axis).getHeading(level);
            ReportGroup group = new ReportGroup();
            group.setName(name);
            // make sure we are not adding a new group with a non-unique name
            List groups = heading.getReportGroups();
            if (groups != null && groups.contains(group)) 
            {
                scarabR.setAlertMessage(L10NKeySet.DuplicateGroupName);
            }
            else
            {
                heading.addReportGroup(group);
                
                params.remove("groupname_new");
                //params.setString("groupname_" + index, group.getName());
                scarabR.setConfirmMessage(L10NKeySet.GroupAdded);
            }

            /* intake way
            UIReportGroup group = new UIReportGroup();
            Group intakeGroup = intake.get("UIReportGroup", 
                                           group.getQueryKey(), false);
            if (intakeGroup != null) 
            {
                intakeGroup.setProperties(group);
                if (group.getDisplayValue() != null 
                     && group.getDisplayValue().length() > 0) 
                {
                    ReportHeading heading = report.getReportDefinition()
                        .getAxis(axis).getHeading(level);
                    ReportGroup rgroup = new ReportGroup();
                    rgroup.setName(group.getDisplayValue());
                    heading.addReportGroup(rgroup);
                }
            }
            */
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doDeletegroup(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }
        
                String[] groupIndices = params.getStrings("selectgroup");
        if (groupIndices == null || groupIndices.length == 0) 
        {
            scarabR.setAlertMessage(L10NKeySet.NoGroupSelected);
        }
        else
        {
            int axis = params.getInt("axis", 0); // 0=row; 1=column
            int level = params.getInt("heading", -1);
            List reportGroups = report.getReportDefinition()
                .getAxis(axis).getHeading(level).getReportGroups();

            for (int j = groupIndices.length-1; j>=0; j--) 
            {
                reportGroups.remove(Integer.parseInt(groupIndices[j]));
            }
            scarabR.setConfirmMessage(L10NKeySet.SelectedGroupDeleted);
                        
            /* intake way
            for (int i=groups.size()-1; i>=0; i--) 
            {
                ReportGroup rgroup = (ReportGroup)groups.get(i);
                UIReportGroup uirg = new UIReportGroup(rgroup.getName());
                Group intakeGroup = intake.get("UIReportGroup", 
                                               uirg.getQueryKey(), false);
                if (intakeGroup != null) 
                {
                    intakeGroup.setProperties(uirg);
                    if (uirg.isSelected())
                    {
                        groups.remove(i);
                    }
                }
            }
            */
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doEditgroupname(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }
        
        Object[] keys =  params.getKeys();
        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        List reportGroups = report.getReportDefinition()
            .getAxis(axis).getHeading(level).getReportGroups();

        for (int i =0; i < keys.length; i++)
        {
            String key = keys[i].toString();
            if (key.startsWith("groupname_") && key.indexOf("new") == -1)
            {
                int index = Integer.parseInt(key.substring(key.indexOf("_")+1,
                                             key.length()));
                ReportGroup group = (ReportGroup)reportGroups.get(index);
                String name = params.getString(key, "").trim();
                if (name.length() == 0)
                {
                    scarabR.setAlertMessage(L10NKeySet.InvalidGroupName);
                }
                else
                {
                    group.setName(name);
                }
            }
        }
        scarabR.setConfirmMessage(L10NKeySet.GroupsChanged);
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSavegroups(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);
        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        List reportGroups = heading.getReportGroups();
        // the form contains data to restore the groups and it is 
        // easier to start from scratch but grab a copy of the option/users
        // before resetting them to null.
        List groupedAttributes = heading.retrieveGroupedAttributes();
        for (Iterator i = reportGroups.iterator(); i.hasNext();) 
        {
            ReportGroup group = (ReportGroup)i.next();
            group.reset();
        }

        boolean success = true;
        if (heading.calculateType() == 0) 
        {
            for (Iterator j = groupedAttributes.iterator(); j.hasNext();) 
            {
                ReportOptionAttribute reportOption = 
                    (ReportOptionAttribute)j.next();
                String name = params.getString("option_" + 
                                               reportOption.getOptionId());
                if (name == null || name.trim().length() == 0) 
                {
                    scarabR.setAlertMessage(L10NKeySet.InvalidGroupName);
                    success = false;
                    break;
                }
                else 
                {
                    for (Iterator i = reportGroups.iterator(); i.hasNext();) 
                    {
                        ReportGroup group = (ReportGroup)i.next();
                        if (name.equals(group.getName())) 
                        {
                            group.addReportOptionAttribute(reportOption);
                        }
                    }
                }                
            }
        }
        else 
        {
            for (Iterator j = groupedAttributes.iterator(); j.hasNext();) 
            {
                ReportUserAttribute reportUser = 
                    (ReportUserAttribute)j.next();
                String name = params.getString(new StringBuffer(20)
                    .append("att_").append(reportUser.getAttributeId())
                    .append("user_").append(reportUser.getUserId()).toString());
                if (name == null || name.trim().length() == 0) 
                {
                    scarabR.setAlertMessage(L10NKeySet.InvalidGroupName);
                    success = false;
                    break;
                }
                else 
                {
                    for (Iterator i = reportGroups.iterator(); i.hasNext();) 
                    {
                        ReportGroup group = (ReportGroup)i.next();
                        if (name.equals(group.getName())) 
                        {
                            group.addReportUserAttribute(reportUser);
                        }
                    }
                }                
            }
        }

        if (success) 
        {
            setTarget(data, "reports,AxisConfiguration.vm");
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAdddate(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }


        int axis = params.getInt("axis", 0); // 0=row; 1=column
        int level = params.getInt("heading", -1);

        ReportHeading heading = report.getReportDefinition()
            .getAxis(axis).getHeading(level);
        // if level was -1, we have created a new level.  So mark the new
        // level as the current one.
        params.setString("heading", "0");
        
        List dates = heading.getReportDates();
        int index = 1;
        if (dates == null)
        {
            // make sure the heading does not contain old option or user data
            heading.reset();
        }
        else 
        {
            index = dates.size() + 1;
        }
        Calendar cal = scarabR.getCalendar();
        cal.set(Calendar.YEAR, params.getInt("y_" + index));
        cal.set(Calendar.MONTH, params.getInt("m_" + index) - 1);
        cal.set(Calendar.DAY_OF_MONTH, params.getInt("d_" + index));
        cal.set(Calendar.HOUR_OF_DAY, params.getInt("h_" + index));
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        ReportDate rdate = new ReportDate();
        rdate.setTime(cal.getTime().getTime());
        heading.addReportDate(rdate);
        scarabR.setConfirmMessage(L10NKeySet.DateAdded);
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doAdddaterange(RunData data, TemplateContext context)
    throws Exception
    {
    	setup(data,context);
    	if (!report.isEditable(user)) 
    	{
    		setNoPermissionMessage();
    		setTarget(data, "reports,ReportList.vm");
    		return;
    	}


    	int axis = params.getInt("axis", 0); // 0=row; 1=column
    	int level = params.getInt("heading", -1);

    	ReportHeading heading = report.getReportDefinition()
        	.getAxis(axis).getHeading(level);
    	// if level was -1, we have created a new level.  So mark the new
    	// level as the current one.
    	params.setString("heading", "0");
    
    	List dates = heading.getReportDateRanges();
    	int index = 1;
    	if (dates == null)
    	{
    		// make sure the heading does not contain old option or user data
    		heading.reset();
    	}
    	else 
    	{
    		index = dates.size() + 1;
    	}

    	ReportDateRange rdaterange = new ReportDateRange();
    	
    	String stateChangeFromDate = ScarabUtil.findValue(data, "stateChangeFromDate");
    	String stateChangeToDate = ScarabUtil.findValue(data, "stateChangeToDate");
    	
    	boolean datesValid = true;
    	
    	if(stateChangeFromDate != null)
        {
    		
    		if(ScarabUtil.validateDateFormat(stateChangeFromDate, user.getLocale()))
                {
    		
    			rdaterange.setMinDateString(stateChangeFromDate);
    		
    		}
    		else
                {
    			
    			datesValid = false;
    			
    		}
    		
    	}
    	
    	if(stateChangeToDate != null)
        {
    		
    		if(ScarabUtil.validateDateFormat(stateChangeToDate, user.getLocale()))
                {
    		
    			rdaterange.setMaxDateString(stateChangeToDate);
    		
    		}
    		else
                {
    			
    			datesValid = false;
    			
    		}
    		
    	}
    	
    	if(stateChangeFromDate == null && stateChangeToDate == null)
        {
    		
    		datesValid = false;
    		
    	}
    	
    	if(datesValid)
        {
    		
    		heading.addReportDateRange(rdaterange);
        	
        	scarabR.setConfirmMessage(L10NKeySet.DateAdded);
    		
    	}
    	else{
    		
    		L10NMessage msg = new L10NMessage(L10NKeySet.DateFormatPrompt,L10NKeySet.ShortDateDisplay);
            scarabR.setAlertMessage(msg);
    		
    	}
    	   	
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doDeletedate(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }
        
        String[] dateIndices = params.getStrings("selectdate");
        if (dateIndices == null || dateIndices.length == 0) 
        {
            scarabR.setAlertMessage(L10NKeySet.NoDateSelected);
        }
        else
        {
            int axis = params.getInt("axis", 0); // 0=row; 1=column
            int level = params.getInt("heading", -1);
            List reportDates = report.getReportDefinition()
                .getAxis(axis).getHeading(level).getReportDates();

            for (int j = dateIndices.length-1; j>=0; j--) 
            {
                reportDates.remove(Integer.parseInt(dateIndices[j])-1);
            }
            scarabR.setConfirmMessage(L10NKeySet.SelectedDateDeleted);
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doDeletedaterange(RunData data, TemplateContext context)
    throws Exception
    {
    	setup(data,context);
    
    	if (!report.isEditable(user)) 
    	{
    		setNoPermissionMessage();
    		setTarget(data, "reports,ReportList.vm");
    		return;
    	}
    
    	String[] dateIndices = params.getStrings("selectdaterange");
    	if (dateIndices == null || dateIndices.length == 0) 
    	{
    		scarabR.setAlertMessage(L10NKeySet.NoDateSelected);
    	}
    	else
    	{
    		int axis = params.getInt("axis", 0); // 0=row; 1=column
    		int level = params.getInt("heading", -1);
    		List reportDateRanges = report.getReportDefinition()
            	.getAxis(axis).getHeading(level).getReportDateRanges();

        for (int j = dateIndices.length-1; j>=0; j--) 
        {
        	reportDateRanges.remove(Integer.parseInt(dateIndices[j])-1);
        }
        
        scarabR.setConfirmMessage(L10NKeySet.SelectedDateDeleted);
        
    }
}
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doRedirecttocrossmodulelist(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data,context);
        // x-module/issuetype works off of user's list, so make the report
        // list the current user's list.
        user.setCurrentMITList(
            report.getMITList());
        setTarget(data, "reports,XModuleList.vm");
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doConfinedataset(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        
        if ("fixed".equals(params.getString("def_date"))) 
        {
            Calendar cal = scarabR.getCalendar();
            cal.set(Calendar.YEAR, params.getInt("def_yr"));
            cal.set(Calendar.MONTH, params.getInt("def_month") - 1);
            cal.set(Calendar.DAY_OF_MONTH, params.getInt("def_day"));
            cal.set(Calendar.HOUR_OF_DAY, params.getInt("def_hr"));
            cal.set(Calendar.MINUTE, 0);
            cal.set(Calendar.SECOND, 0);
            report.setDefaultDate(cal.getTime());
        }
        else 
        {
            report.setDefaultDate(null);
        }
        scarabR.setConfirmMessage(L10NKeySet.ChangesSaved);
        setTarget(data, "reports,ConfineDataset.vm");
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSwaprowcol(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        
        if (!report.isEditable(user)) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");
            return;
        }

              

        ReportDefinition reportDefn = report.getReportDefinition();
        List axes = reportDefn.getReportAxisList();
        if (axes != null && !axes.isEmpty()) 
        {
            if (axes.size() == 1) 
            {
                reportDefn.addReportAxis(new ReportAxis());
            }
            ReportAxis row = (ReportAxis)axes.remove(0);
            // add back as column
            reportDefn.addReportAxis(row);            
        }
        
        // FIXME: do we need a confirmation message? -jon
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doVerifyreport(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data,context);
        if (report.removeStaleDefinitions()) 
        {
            scarabR.setInfoMessage(l10n.get("ReportDefinitionModified"));
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doGeneratereport(RunData data, TemplateContext context)
         throws Exception
    {
        setup(data,context);

        if (report.removeStaleDefinitions()) 
        {
            scarabR.setInfoMessage(l10n.get("ReportDefinitionModified"));
        }
        else if (report.getReportDefinition().reportQueryIsExpensive() ) 
        {
            scarabR.setAlertMessage(l10n.format("ReportIsTooExpensive", String.valueOf( 
                             report.getReportDefinition().maximumHeadings())));
        }
        else 
        {
        // Determine the report display format, looking first at the
        // request parameters.
        String format = ScarabUtil.findValue(data, ExportFormat.KEY_NAME);
        if (StringUtils.isEmpty(format))
        {
            // Next, examine the request for the Intake parameter
            // (which we'll allow to override a persisted pref).
            Group intakeReport = getIntakeReportGroup(getIntakeTool(context),
                                                      report);
            // Exports from the "Report output" screen have a null
            // Intake Group.
            if (intakeReport != null)
            {
                format = (String) intakeReport.get("Format").getValue();
            }

            if (format == null)
            {
                // Lastly, look at the persisted report format.
                format = report.getFormat();
            }
        }

        if (ExportFormat.EXCEL_FORMAT.equalsIgnoreCase(format)
            || ExportFormat.TSV_FORMAT.equalsIgnoreCase(format))
        {
            // The ReportExport screen has no corresponding template.
            data.getParameters().setString(ExportFormat.KEY_NAME, format);
            setTarget(data, "ReportExport.vm");
        }
        else
        {
            setTarget(data, "reports,Report_1.vm");
        }
            
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doCreatenew(RunData data, TemplateContext context)
        throws Exception
    {
        String key = data.getParameters()
            .getString(ScarabConstants.CURRENT_REPORT);
        data.getParameters().remove(ScarabConstants.CURRENT_REPORT);
        ScarabUser user = (ScarabUser)data.getUser();
        if (key != null && key.length() > 0) 
        {
            user.setCurrentReport(key, null);
        }
        if (user.getCurrentMITList() == null) 
        {
            //context.add("report", Boolean.TRUE);  
            setTarget(data, "reports,XModuleList.vm");
        }
        else 
        {
            setTarget(data, "reports,Info.vm");
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doSavereport(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);        
        
        if (!report.isSavable((ScarabUser)data.getUser())) 
        {
            setNoPermissionMessage();
            setTarget(data, "reports,ReportList.vm");                        
        }
        else if (intake.isAllValid()) 
        {
            // make sure report has a name
            if (report.getName() == null || report.getName().trim().length() == 0) 
            {
                Group intakeReport = getIntakeReportGroup(intake, report);
                if (intakeReport != null) 
                {   
                    intakeReport.setValidProperties(report);
                }
            }

            if (report.getName() == null || report.getName().trim().length() == 0) 
            {
                scarabR.setAlertMessage(L10NKeySet.SavedReportsMustHaveName);
                setTarget(data, "reports,Info.vm");
            }
            else 
            {
                //don't save extra whitespace as part of name.
                String name = report.getName().trim();
                report.setName(name);
                // make sure name is unique, mysql text queries are 
                // case-insensitive, otherwise we may need to do this
                // differently to avoid similar but not exact matches.
                org.tigris.scarab.om.Report savedReport = ReportPeer
                    .retrieveByName(name);
                if (savedReport == null 
                    || savedReport.getQueryKey().equals(report.getQueryKey()))
                {
                    report.save();
                    scarabR.setConfirmMessage(L10NKeySet.ReportSaved);
                }
                else 
                {
                    scarabR.setAlertMessage(L10NKeySet.ReportNameNotUnique);
                    setTarget(data, "reports,Info.vm");
                }
            }
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.ErrorPreventedSavingReport);
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
public void doDeletestoredreport(RunData data, TemplateContext context)
        throws Exception
    {
        setup(data,context);
        ScarabUser user = (ScarabUser)data.getUser();
        String[] reportIds = data.getParameters().getStrings("report_id");
        if (reportIds == null || reportIds.length == 0) 
        {
            scarabR.setAlertMessage(l10n.get("MustSelectReport"));
        }
        else 
        {
            for (int i=0;i<reportIds.length; i++)
            {
                String reportId = reportIds[i];
                if (reportId != null && reportId.length() > 0)
                {
                    Report torqueReport = ReportManager
                        .getInstance(new NumberKey(reportId), false);
                    if (new ReportBridge(torqueReport).isDeletable(user)) 
                    {
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }                   
                    else 
                    {
                        setNoPermissionMessage();
                    }
                }
            }
        }        
    }
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
private Group getIntakeReportGroup(Intake intake, ReportBridge report)
        throws Exception
    {
        Group intakeReport = intake.get("Report", report.getQueryKey(), false);
        if (intakeReport == null) 
        {   
            intakeReport = intake.get("Report", "", false);
        }
        return intakeReport;
    }
            
// in java/org/tigris/scarab/actions/Register.java
public void doRegister(RunData data, TemplateContext context) 
        throws Exception
    {
        String template     = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        if(!intake.isAllValid())
            return;
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);

        Group register = intake.get("Register", IntakeTool.DEFAULT_KEY, false);

        String password = register.get("Password").toString();
        String passwordConfirm = register.get("PasswordConfirm").toString();

        if (!password.equals(passwordConfirm))
        {
            setTarget(data, template);
            scarabR.setAlertMessage(L10NKeySet.PasswordsDoNotMatch);
            return;
        }

        ScarabUser su = ScarabUserManager.getInstance();
        register.setProperties(su);
        
        if(!su.hasValidEmailAddress())
        {
            setTarget(data,template);
            scarabR.setAlertMessage(L10NKeySet.EnterValidEmailAddress);
            return;
        }
        
        ScarabUser existingUser=ScarabUserManager.getInstance(su.getUserName());
        if (existingUser!=null)
        {
            setTarget(data, template);
            scarabR.setAlertMessage(L10NKeySet.UsernameExistsAlready);
            return;
        }

        data.getUser().setTemp(ScarabConstants.SESSION_REGISTER, su);
        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/Register.java
public void doConfirmregistration(RunData data, TemplateContext context)
        throws Exception
    {
        String nextTemplate = getNextTemplate(data);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        ScarabUser su = (ScarabUser) data.getUser()
            .getTemp(ScarabConstants.SESSION_REGISTER);

        if (su == null)
        {
            setTarget(data, "Register.vm");
            return;
        }
        
        try
        {
            su.createNewUser();
        }
        catch (org.apache.fulcrum.security.util.EntityExistsException e)
        {
            su = ScarabUserManager.reactivateUserIfDeleted(su);
            if (su == null)
            {
                ScarabUser existingUser = ScarabUserManager.getInstance(su.getUserName());
                if(existingUser.isConfirmed())
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UsernameExistsAlready);
                    scarabR.setAlertMessage(msg);
                    setTarget(data, "Login.vm");
                    return;
                }
                else
                {
                    su = existingUser;
                }
            }
        }
        data.getUser().setTemp(ScarabConstants.SESSION_REGISTER, null);
       scarabR.setUser(su);
        sendConfirmationEmail(su, context);

        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/Register.java
public void doBack(RunData data, TemplateContext context) 
        throws Exception
    {
        setTarget(data, data.getParameters().getString(
                ScarabConstants.CANCEL_TEMPLATE, "Register.vm"));
    }
            
// in java/org/tigris/scarab/actions/Register.java
public void doPerform(RunData data, TemplateContext context) 
        throws Exception
    {
        doConfirmregistration(data, context);
    }
            
// in java/org/tigris/scarab/actions/Register.java
public void doConfirm(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        if(!intake.isAllValid())
            return;
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);

        Group register = intake.get("Register", IntakeTool.DEFAULT_KEY, false);


        String username = register.get("UserName").toString();
        String confirm = register.get("Confirm").toString();

        ScarabUser u = ScarabUserManager.getInstance(username);

        if (u.isConfirmed())
        {
            scarabR.setAlertMessage(L10NKeySet.AccountConfirmedSuccess);
            setTarget(data, nextTemplate);
        }
        else
        {
            if (u.confirm(confirm))
            {
                u.save();
                data.getUser().setTemp(ScarabConstants.SESSION_REGISTER, null);

                scarabR.setConfirmMessage(L10NKeySet.AccountConfirmedSuccess);
                setTarget(data, nextTemplate);
            }
            else
            {
                scarabR.setAlertMessage(L10NKeySet.InvalidConfirmationCode);
                setTarget(data, template);
            }
        }
    }
            
// in java/org/tigris/scarab/actions/Register.java
public void doResendconfirmationcode(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
 
        IntakeTool intake = getIntakeTool(context);
        Group register = intake.get("Register", IntakeTool.DEFAULT_KEY, false);
   
        String username = register.get("UserName").toString();
        ScarabUser user = ScarabUserManager.getInstance(username);

        if(user==null)
        {
            String template = getCurrentTemplate(data, null);
            scarabR.setAlertMessage(L10NKeySet.InvalidUsername);
            setTarget(data, template);
            return;
        }
    
        if(user.isConfirmed())
        {
            String template = getCurrentTemplate(data, null);
            scarabR.setAlertMessage(L10NKeySet.AccountConfirmedSuccess);
            setTarget(data, template);
            return;
        }
       scarabR.setUser(user);
        sendConfirmationEmail(user, context);
        scarabR.setConfirmMessage(L10NKeySet.ConfirmationCodeSent);

        setTarget(data, "Confirm.vm");
    }
            
// in java/org/tigris/scarab/actions/Register.java
private void sendConfirmationEmail(ScarabUser su, TemplateContext context)
        throws Exception
    {
        Email te = new Email();

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Locale locale = l10n.getPrimaryLocale();
        String charset = Email.getCharset(locale);
        te.setCharset(charset);

        te.setContext(new ContextAdapter(context));
        te.addTo(su.getEmail(), su.getFirstName() + " " + su.getLastName());
        te.setFrom(
            Turbine.getConfiguration()
                .getString("scarab.email.register.fromAddress",
                           "register@localhost"),
            Turbine.getConfiguration()
                .getString("scarab.email.register.fromName",
                           "Scarab System"));
        te.setSubject(L10NKeySet.ConfirmationSubject.getMessage(l10n));
        te.setTemplate(
            Turbine.getConfiguration()
                .getString("scarab.email.register.template",
                           "email/Confirmation.vm"));
        te.send();        
    }
            
// in java/org/tigris/scarab/actions/TemplateList.java
public void doCreatenew(RunData data, TemplateContext context)
         throws Exception
    {        
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssueTemplate();
        if (issue == null)
        {
            scarabR.setAlertMessage(L10NKeySet.IssueTypeNotAvailable);
            return;
        }

        LinkedMap avMap = issue.getModuleAttributeValuesMap();
        AttributeValue aval = null;
        Group group = null;
        
        IssueTemplateInfo info = scarabR.getIssueTemplateInfo();
        Group infoGroup = intake.get("IssueTemplateInfo", info.getQueryKey());
        Group issueGroup = intake.get("Issue", issue.getQueryKey());
        ActivitySet activitySet = null;

        if (intake.isAllValid()) 
        {
            issueGroup.setProperties(issue);
            infoGroup.setProperties(info);
            if (checkForDupes(info, infoGroup.get("Name").toString(), 
                              user, issue))
            {
                scarabR.setAlertMessage(L10NKeySet.DuplicateTemplateName);
            }
            else
            {
                boolean atLeastOne = false;
                MapIterator iter = avMap.mapIterator();
                if (iter.hasNext()) 
                {
                    // Save activitySet record
                    activitySet = ActivitySetManager
                        .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
                    activitySet.save();
                    while (iter.hasNext()) 
                    {
                        aval = (AttributeValue)avMap.get(iter.next());
                        group = intake.get("AttributeValue", aval.getQueryKey(),false);
                        String value = null;
                        if (group != null)
                        {
                            if (aval instanceof OptionAttribute) 
                            {
                                value = group.get("OptionId").toString();
                            }
                            else 
                            {
                                value = group.get("Value").toString();
                            }
                            if (StringUtils.isNotEmpty(value))
                            {
                                atLeastOne = true;
                                aval.startActivitySet(activitySet);
                                group.setProperties(aval);
                            }
                        }
                    }
                }
                if (atLeastOne)
                {
                    issue.setCreatedTransId(activitySet.getActivitySetId());
                    issue.save();
                    info.setIssueId(issue.getIssueId());

                    // Save template info
                    info.saveAndSendEmail(user, 
                        scarabR.getCurrentModule(),
                        context);

                    // For a module-scoped template which is now
                    // pending approval, the user may not have
                    // permission to edit the new issue template.
                    if (info.canEdit(user))
                    {
                        data.getParameters().add
                            ("templateId", issue.getIssueId().toString());
                        scarabR.setConfirmMessage(L10NKeySet.NewTemplateCreated);
                    }
                    else
                    {
                        // Display the list of issue templates.
                        scarabR.setInfoMessage(
                            l10n.format("NotifyPendingApproval",
                            l10n.get("Template").toLowerCase()));
                        setTarget(data, "TemplateList.vm");
                        doPerform(data, context);
                    }
                }
                else
                {
                    scarabR.setAlertMessage(
                                L10NKeySet.AtLeastOneAttributeForTemplate);
                }
            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
            
// in java/org/tigris/scarab/actions/TemplateList.java
public void doEditvalues(RunData data, TemplateContext context)
         throws Exception
    {        
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssueTemplate();

        LinkedMap avMap = issue.getModuleAttributeValuesMap();
        AttributeValue aval = null;
        Group group = null;
        Group issueGroup = intake.get("Issue", issue.getQueryKey());
        issueGroup.setProperties(issue);

        if (intake.isAllValid()) 
        {
            AttributeValue aval2 = null;
            HashMap newAttVals = new HashMap();
            boolean modifiedAttribute = false;

            Iterator iter = avMap.mapIterator();
            while (iter.hasNext()) 
            {
                aval = (AttributeValue)avMap.get(iter.next());
                aval2 = AttributeValue.getNewInstance(aval.getAttributeId(),
                                                      aval.getIssue());
                aval2.setProperties(aval);
                group = intake.get("AttributeValue", aval.getQueryKey(),false);
                if (group != null)
                {
                    String newValue = "";
                    String oldValue = "";
                    if (aval instanceof OptionAttribute) 
                    {
                        newValue = group.get("OptionId").toString();
                        oldValue = aval.getOptionIdAsString();
                    
                        if (!newValue.equals(""))
                        {
                            AttributeOption newAttributeOption =
                              AttributeOptionManager
                              .getInstance(new Integer(newValue));
                            newValue = newAttributeOption.getName();
                        }
                        if (!oldValue.equals(""))
                        {
                            Integer oldOptionId = aval.getOptionId();
                            AttributeOption oldAttributeOption =
                              AttributeOptionManager
                              .getInstance(oldOptionId);
                            oldValue = oldAttributeOption.getName();
                        }
                        
                    }
                    else 
                    {
                        newValue = group.get("Value").toString();
                        oldValue = aval.getValue();
                    }
                    // A value has been entered for the attribute.
                    // The old value is different from the new, or is unset:
                    // Set new value.
                    if (newValue.trim().length() > 0 && (oldValue == null ||
                          !newValue.trim().equals(oldValue.trim())))
                    {
                        group.setProperties(aval2);
                        newAttVals.put(aval.getAttributeId(), aval2);
                        modifiedAttribute = true;
                    }
                    // The attribute is being undefined.
                    else if (oldValue != null && newValue.trim().length() == 0 &&
                             oldValue.trim().length() != 0)
                    {
                        aval2.setValue(null);
                        newAttVals.put(aval.getAttributeId(), aval2);
                        modifiedAttribute = true;
                    }
                }                
            }
            //save data only if there is a change
            if (modifiedAttribute)
            {
                issue.setAttributeValues(null, newAttVals, null, user);
                intake.removeAll();
            }
            scarabR.setConfirmMessage(L10NKeySet.TemplateModified);
        } 
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
            
// in java/org/tigris/scarab/actions/TemplateList.java
public boolean doEdittemplateinfo(RunData data, TemplateContext context)
         throws Exception
    {        
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssueTemplate();
        boolean success = true;

        IssueTemplateInfo info = scarabR.getIssueTemplateInfo();
        Group infoGroup = intake.get("IssueTemplateInfo", info.getQueryKey());

        if (intake.isAllValid()) 
        {
            infoGroup.setProperties(info);
            info.setIssueId(issue.getIssueId());
            if (checkForDupes(info, infoGroup.get("Name").toString(),
                              user, issue))
            {
                success = false;
                scarabR.setAlertMessage(L10NKeySet.DuplicateTemplateName);
            }
            else
            {
                // Save template info
                info.saveAndSendEmail(user, scarabR.getCurrentModule(), context);
                data.getParameters().add("templateId", issue.getIssueId().toString());
                if (info.canEdit(user))
                {
                    scarabR.setConfirmMessage(L10NKeySet.TemplateModified);
                }
                else
                {
                    scarabR.setInfoMessage(
                                    l10n.format("NotifyPendingApproval",
                                    l10n.get("Template").toLowerCase()));
                    setTarget(data, data.getParameters().getString(
                                    ScarabConstants.CANCEL_TEMPLATE));
                }
            }
        }
        else
        {
            success = false;
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/TemplateList.java
public void doDeletetemplates(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Object[] keys = data.getParameters().getKeys();
        String key;
        String templateId;
        ScarabUser user = (ScarabUser)data.getUser();
        boolean atLeastOne = false;
        boolean success = true;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
                atLeastOne = true;
                templateId = key.substring(7);
                try
                {
                    Issue issue = IssueManager
                       .getInstance(new NumberKey(templateId), false);
                    if (issue == null)
                    {
                        throw new Exception(
                            l10n.get("CouldNotLocateTemplateToDelete")); //EXCEPTION
                    }
                    issue.deleteItem(user);
                }
                catch (ScarabException e)
                {
                    success = false;
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
                catch (Exception e)
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.getMessage(e));
                }
            }
        } 
        if (!atLeastOne)
        {
            scarabR.setAlertMessage(L10NKeySet.NoTemplateSelected);
        }
        else if (success)
        {
            scarabR.setConfirmMessage(L10NKeySet.TemplateDeleted);
        } 
    }
            
// in java/org/tigris/scarab/actions/TemplateList.java
public void doUsetemplate(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        intake.removeAll();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String templateId = data.getParameters().getString("templateId");
        if (templateId != null && templateId.length() > 0) 
        {
            IssueType templateType = IssueManager.getInstance(
                new Long(templateId)).getIssueType();
            setTarget(data, scarabR.getNextEntryTemplate(
                templateType.getIssueTypeForTemplateType()));
            ReportIssue.cleanOutStaleIssue(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/TemplateList.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        doEditvalues(data, context);
        doEdittemplateinfo(data, context);
    }
            
// in java/org/tigris/scarab/actions/TemplateList.java
private boolean checkForDupes(IssueTemplateInfo template, 
                                  String newName, ScarabUser user, 
                                  Issue issueTemplate)
        throws Exception
    {
        boolean areThereDupes = false;
        Module module = issueTemplate.getModule();
        List prevTemplates = IssueTemplateInfoPeer.getUserTemplates(user, 
            module, issueTemplate.getIssueType().getIssueTypeForTemplateType());
        if (template.getScopeId().equals(Scope.MODULE__PK))
        {
            prevTemplates.addAll(IssueTemplateInfoPeer.getModuleTemplates(module));
        }
        if (prevTemplates != null && !prevTemplates.isEmpty())
        {
            Long pk = template.getIssueId();
            for (Iterator i = prevTemplates.iterator(); 
                 i.hasNext() && !areThereDupes;)
            {
                IssueTemplateInfo  t = (IssueTemplateInfo)i.next();
                areThereDupes = ((pk == null || !pk.equals(t.getIssueId())) &&
                    newName.trim().toLowerCase().equals(
                        t.getName().trim().toLowerCase()));
            }
        }
        return areThereDupes;
    }
            
// in java/org/tigris/scarab/actions/TemplateList.java
public void doDone(RunData data, TemplateContext context)  
        throws Exception
    {
        boolean success = doEdittemplateinfo(data, context);
        if (success)
        {
            doEditvalues(data, context);
            doCancel(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doGotoquerywithinternallist(RunData data,
                                            TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String listId = data.getParameters().getString("pd_list_id");
        if (listId == null || listId.length()==0)
        {
            scarabR.setAlertMessage(L10NKeySet.NoPredefinedXModuleListSelected);
        }
        else 
        {
            MITList list = null;
            ScarabUser user = (ScarabUser)data.getUser();
            if ("allmits".equals(listId)) 
            {
                list = MITListManager.getAllModulesAllIssueTypesList(user);
            }
            else 
            {
                IssueType issueType = IssueTypeManager
                    .getInstance(new Integer(listId.substring(13)));
                if (issueType.getDeleted()) 
                {

                    scarabR.setAlertMessage(L10NKeySet.GlobalIssueTypesDeleted);
                }
                else 
                {
                    list = MITListManager.getAllModulesSingleIssueTypeList(
                        issueType, user);                    
                }
            }
            user.setCurrentMITList(list);
            // reset selected users map
            scarabR.resetSelectedUsers();
            setTarget(data, data.getParameters()
                      .getString(ScarabConstants.NEXT_TEMPLATE));
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doFinished(RunData data, TemplateContext context)
        throws Exception
    {
        // add any last minute additions
        ScarabUser user = (ScarabUser)data.getUser();
        user.setCurrentMITList(new MITList());
        addSelectedRMITs(data, context);
        MITList currentList = user.getCurrentMITList();
        // reset selected users map
        getScarabRequestTool(context).resetSelectedUsers();

        if (currentList != null && !currentList.isEmpty()) 
        {
            setTarget(data, user.getQueryTarget());
        }
        else
        {
            ScarabRequestTool scarabR = getScarabRequestTool(context);
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            scarabR.setAlertMessage(L10NKeySet.ListWithAtLeastOneMITRequired);
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doFinishedreportlist(RunData data, TemplateContext context)
        throws Exception
    {
        doFinished(data, context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ReportBridge report = scarabR.getReport();
        if (!report.isEditable(user)) 
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            setTarget(data, "reports,ReportList.vm");
            return;
        }

        MITList mitList = user.getCurrentMITList();
        try 
        {
            report.setMITList(mitList);
            scarabR.setConfirmMessage(DEFAULT_MSG);

            if (!mitList.isSingleModule() && 
                Scope.MODULE__PK.equals(report.getScopeId())) 
            {
                report.setScopeId(Scope.PERSONAL__PK);
                scarabR.setInfoMessage(L10NKeySet.ScopeChangedToPersonal);
            }
            setTarget(data, "reports,Info.vm");
        }
        catch (IncompatibleMITListException e)
        {
            scarabR.setAlertMessage(L10NKeySet.IncompatibleMITListReport);
            setTarget(data, "reports,XModuleList.vm");
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doRemoveSavedlist(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String listId = data.getParameters().getString("list_id");
        if (listId == null || listId.length()==0)
        {
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            scarabR.setAlertMessage(L10NKeySet.NoSavedXModuleQuerySelected);
        }
        else 
        {
            // TODO: implement
        }        
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doRemoveitemsfromlist(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        String[] mitids = data.getParameters().getStrings("mitlistitem");
        if (mitids == null || mitids.length == 0) 
        {
            scarabR.setAlertMessage(L10NKeySet.NoItemsSelectedForRemoval);
        }
        else 
        {
            user.removeItemsFromCurrentMITList(mitids);
            scarabR.setConfirmMessage(
                l10n.format("NumberItemsRemoved", String.valueOf(mitids.length)));
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doGotosavelist(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        MITList list = user.getCurrentMITList();
        if (list == null) 
        {
            scarabR.setAlertMessage(L10NKeySet.ApplicationErrorListWasNull);
            Log.get().error("Current list was null in DefineXModuleList.doGotosavelist.");
        }
        else if (list.isAnonymous())
        {
            list.save();
            scarabR.setConfirmMessage(DEFAULT_MSG);
            String queryId = data.getParameters().getString("queryId");
            if (queryId != null && queryId.length() > 0) 
            {
                setTarget(data, "EditQuery.vm");
            }
        }
        else
        {
            list.setName(null);
            setTarget(data, "EditXModuleList.vm");
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doStartover(RunData data, TemplateContext context)
        throws Exception
    {
        ((ScarabUser)data.getUser()).setCurrentMITList(null);
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doSavelist(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
       
        if (intake.isAllValid()) 
        {
            ScarabUser user = (ScarabUser)data.getUser();
            MITList list = user.getCurrentMITList();
            Group group = 
                intake.get("MITList", list.getQueryKey(), false);
            group.setProperties(list);
            // check if the name already exists and inactivate the old list
            MITList oldList = MITListManager
                .getInstanceByName(list.getName(), user);
            if (oldList != null) 
            {
                // oldList should not be the same as the new, but checking
                // will not hurt
                if (!list.equals(oldList)) 
                {                                    
                    oldList.setActive(false);
                    oldList.save();
                }
            }
            // save the new list
            list.save();

            // Setting the current list to null
            // So that on IssueTypeList screen can select a saved list
            user.setCurrentMITList(null);
 
            scarabR.setConfirmMessage(DEFAULT_MSG);
            setTarget(data, data.getParameters()
                      .getString(ScarabConstants.LAST_TEMPLATE));
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doAddselectedrmits(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String[] rmitIds = data.getParameters().getStrings("rmitid");
        String listId = data.getParameters().getString("list_id");
        if ( (listId == null || listId.length() == 0)
             && (rmitIds == null || rmitIds.length == 0)
             && !data.getParameters().getBoolean("allit"))
        {
            scarabR.setAlertMessage(L10NKeySet.MustSelectAtLeastOneIssueType);
            return;
        }
        else 
        {
            addSelectedRMITs(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
private void addSelectedRMITs(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        String listId = data.getParameters().getString("list_id");
        if (listId != null && listId.length() != 0)
        {
            setAndGetCurrentList(listId, data, context);   
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (data.getParameters().getBoolean("allit")) 
        {
            Module module = user.getCurrentModule();
            List issueTypes = module.getIssueTypes(false);
            if (issueTypes == null || issueTypes.isEmpty())
            {
                scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                return;
            }
            MITList list = MITListManager.getSingleModuleAllIssueTypesList(
                module, user);
            addToUsersList(user, list.copy());
        }

        String[] rmitIds = data.getParameters().getStrings("rmitid");
        if (rmitIds != null && rmitIds.length != 0) 
        {
            List rmits = new ArrayList(rmitIds.length);
            boolean isIssueTypeAvailable = true;
            for (int i=0; i<rmitIds.length && isIssueTypeAvailable; i++)
            {
                try
                {
                    RModuleIssueType rmit = RModuleIssueTypeManager
                        .getInstance(rmitIds[i]);
                    if (rmit == null || rmit.getIssueType().getDeleted())
                    {
                        isIssueTypeAvailable = false;
                    }
                    else
                    {
                        rmits.add(rmit);
                    }
                }
                catch (Exception e)
                {
                    // would probably be a hack of the form
                    scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                    Log.get().debug("", e);
                    return;
                }
            }
            if (isIssueTypeAvailable)
            {
                user.addRMITsToCurrentMITList(rmits);
            }
            else
            {
                scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
            }
        }
        
        // Another oddity due to ScarabUserImpl not extending
        // AbstractScarabUser
        MITList mitlist = user.getCurrentMITList();
        if (mitlist != null) 
        {
            mitlist.setScarabUser(user);            
        }
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
public void doToggleothermodules(RunData data, TemplateContext context)
        throws Exception
    {
        String flag = data.getParameters()
            .getString("eventSubmit_doToggleothermodules");
        ((ScarabUser)data.getUser()).setShowOtherModulesInIssueTypeList(
            "show".equals(flag));
    }
            
// in java/org/tigris/scarab/actions/ViewIssue.java
public void doSetissueview(RunData data, TemplateContext context)
         throws Exception
    {
        // fetch property here so it can be changed at runtime
        final boolean singleScreenOnly = Turbine.getConfiguration()
            .getBoolean(ScarabConstants.SINGLE_SCREEN_ONLY, false);
        // the velocity template hides the link to actually get here,
        //  but just to be extra secure.
        
        String tabmode = data.getParameters().getString("tabmode");
        
        if(tabmode == null){
       	 
       	 	tabmode = (String)data.getUser().getTemp("tabmode");
       	 	
       	 	if(tabmode == null){
         	
       	 		if(singleScreenOnly){
             	
       	 			tabmode = "all";
             	
       	 		}
       	 		else{
             	
             		tabmode = "tabs";
             	
       	 		}
         	
       	 	}
       	 
        }
         
         String tab = null;
         
         if(tabmode.equals("all")){
        	 
        	 tab = ScarabConstants.ISSUE_VIEW_ALL;
        	 
         }
         else{
        	 
        	 tab = data.getParameters().getString("tab");
        	 
         }
         
         if(tab == null){
        	 
        	 tab = "1";
        	 
         }
         
         data.getUser().setTemp(ScarabConstants.TAB_KEY, tab); 
         data.getUser().setTemp("tabmode", tabmode); 
    }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
public void doUpdate(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        if (intake.isAllValid())
        {
            Module me = null;
            try
            {
                me = scarabR.getModule();
            }
            catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }

            Group moduleGroup = intake.get
                ("Module",me.getQueryKey(), false);

            if (moduleGroup == null)
            {
                setTarget(data, template);
                scarabR.setAlertMessage(
                    L10NKeySet.CouldNotLocateModuleGroup);
                return;
            }
            else
            {
                ScarabUser user = (ScarabUser) data.getUser();

                // make sure that the user has Edit permission 
                // in the module.
                if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, me))
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                    intake.remove(moduleGroup);
                    setTarget(data, nextTemplate);
                    return;
                }

                Module origParent = me.getParent();
                String origCode = me.getCode();
                moduleGroup.setProperties(me);
                Module newParent = me.getParent();
                String newCode = me.getCode();

                if (newParent.getParent() == me && origParent!=me)
                {
                    scarabR.setAlertMessage(L10NKeySet.CircularParentChildRelationship);
                    intake.remove(moduleGroup);
                    setTarget(data, template);
                    return;
                }
                else if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, origParent) && 
                    origParent.getModuleId() != newParent.getModuleId())
                {
                    scarabR.setAlertMessage(L10NKeySet.NoPermissionInParentModule);
                    setTarget(data, template);
                    return;
                }
                
                // Cascade update the code to the (denormalized) issue prefix
                if (! newCode.equals(origCode))
                {
                    if (me instanceof ScarabModule)
                    {
                        ScarabModule sm = (ScarabModule)me;
                        List issues = sm.getIssues();
                        for (int i = 0; i < issues.size(); i++)
                        {
                            Issue issue = (Issue)issues.get(i);
                            if (! issue.getIdPrefix().equals(me.getCode()))
                            {
                                issue.setIdPrefix(me.getCode());
                                issue.save();
                            }
                        }
                        //Update the ID table to reflect the module code r
                        // FIXME: Using SQL because IDBroker doesn't have a Peer yet.
                        String idTable = IDBroker.TABLE_NAME.substring(0, 
                                IDBroker.TABLE_NAME.indexOf('.'));
                        String instanceId = GlobalParameterManager
                        .getString(ScarabConstants.INSTANCE_ID);
                        String sql = "update " + idTable 
                         + " SET TABLE_NAME='" + instanceId + "-" + newCode + "' WHERE TABLE_NAME='" +
                         instanceId + "-" + origCode + "'";
                        BasePeer.executeStatement(sql);                                                
                    }
                    else
                    {
                        throw new Exception ("Did not get a ScarabModule"); //EXCEPTION
                    }
                }
                
                me.save();

                updateModuleParameters(data, me);
                
                intake.remove(moduleGroup);
                setTarget(data, nextTemplate);
                scarabR.setConfirmMessage(L10NKeySet.ModuleUpdated);
            }
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
public void doCreate(RunData data, TemplateContext context) 
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        if (intake.isAllValid())
        {
            Group moduleGroup = intake.get
                ("Module",IntakeTool.DEFAULT_KEY, false);
            Module me = ModuleManager.getInstance();
            if (moduleGroup == null)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
            moduleGroup.setProperties(me);
            ScarabUser user = (ScarabUser)data.getUser();
            
            // make sure that the user has Edit permission 
            // in the parent module.
            if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, 
                me.getParent()))
            {
                scarabR.setAlertMessage(L10NKeySet.NoPermissionInParentModule);
            }
            else
            {
            	try{
	                me.setOwnerId(user.getUserId());
	                me.save();
	                
	                updateModuleParameters(data, me);
	
	                data.setACL(((ScarabUser)data.getUser()).getACL());
	                data.save();
	
	                scarabR.setConfirmMessage(L10NKeySet.NewModuleCreated);
	                intake.remove(moduleGroup);
            	}
                catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
            }
        }
        else
        {
            setTarget(data, template);
            return;
        }
        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/QueryList.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
       
        if (intake.isAllValid())
        {
            boolean valid = true;
            List queries = scarabR.getAllQueries();
            for (int i = 0; i < queries.size(); i++)
            {    
                Query query = (Query)queries.get(i);
                RQueryUser rqu = query.getRQueryUser(user);
                Group queryGroup = intake.get("RQueryUser",
                                              rqu.getQueryKey(), false);
                if (queryGroup != null)
                {
                    Field sub = queryGroup.get("Subscribed");
                    if (sub.toString().equals("true"))
                    {
                        Field freq = queryGroup.get("Frequency");
                        freq.setRequired(true);
                        if (!freq.isValid())
                        {
                            valid = false;
                            freq.setMessage("EnterSubscriptionFrequency");
                        }
                    }                
                    if (valid) 
                    {
                        queryGroup.setProperties(rqu);
                        rqu.save();
                    }
                }
            }
       }
       else
       {
           scarabR.setAlertMessage(ERROR_MESSAGE);
       }
       ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/actions/QueryList.java
public void doDeletequeries(RunData data, TemplateContext context)
        throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key;
        String queryId;
        ScarabUser user = (ScarabUser)data.getUser();

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
               queryId = key.substring(7);
               Query query = QueryManager
                   .getInstance(new NumberKey(queryId), false);
               try
               {
                   query.delete(user);
                   query.save();
               }
               catch (Exception e)
               {
                   ScarabLocalizationTool l10n = getLocalizationTool(context);
                   getScarabRequestTool(context).setAlertMessage(NO_PERMISSION_MESSAGE);
               }

            }
        } 
    }
            
// in java/org/tigris/scarab/actions/QueryList.java
public void doCopyquery(RunData data, TemplateContext context)
        throws Exception
    {
        ParameterParser pp = data.getParameters();
        Object[] keys = pp.getKeys();
        String key;
        String queryId;
        Query query;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
               queryId = key.substring(7);
               query = QueryManager
                   .getInstance(new NumberKey(queryId), false);
               query.copyQuery((ScarabUser)data.getUser());
             }
         }
     }
            
// in java/org/tigris/scarab/actions/QueryList.java
public void doGotoadvancedquery(RunData data, TemplateContext context)
        throws Exception
    {
        // reset the MITList
        ScarabUser user = (ScarabUser)data.getUser();
        user.setCurrentMITList(null);
        // reset selected users map
        getScarabRequestTool(context).resetSelectedUsers();
        setTarget(data, user.getQueryTarget());
    }
            
// in java/org/tigris/scarab/actions/QueryList.java
public void doSetstartpage(RunData data, TemplateContext context) throws Exception
    {
        ParameterParser pp = data.getParameters();   
        String queryId = pp.get("startpage");
        
        List<Query> privateQueries = getScarabRequestTool(context).getUserAllQueries();
        Query newStartQuery = QueryManager.getInstance(new NumberKey(queryId), false);
        
        boolean addedAsStartQuery;
        
        addedAsStartQuery = setStartpage(privateQueries, newStartQuery);       
        if(addedAsStartQuery)
        {
            // We just have added a private query as startPage.
            // We will not deal with the public queries.
            // Consequently we can have more than one startQuery per module.
        }
        else
        {
            // Since we have not marked a personal query as start page we probably
            // are dealing with a public query, hence we must process the public query list
            // too.
            List<Query> globalQueries  = getScarabRequestTool(context).getGlobalQueries();
            setStartpage(globalQueries, newStartQuery);
        }
    }
            
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
    }
            
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doGonext(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getNextTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doGotoothertemplate(RunData data, 
                                     TemplateContext context)
        throws Exception
    {
        data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE,
                                       getCurrentTemplate(data));
        setTarget(data, getOtherTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doRefresh(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getCurrentTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doReset(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        intake.removeAll();
        setTarget(data, getCurrentTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doCancel(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getCancelTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        doSave(data, context);
        doCancel(data, context);
    }
            
// in java/org/tigris/scarab/actions/base/ScarabTemplateAction.java
public void doRefreshresultsperpage(RunData data, TemplateContext context) 
        throws Exception
    {
        ParameterParser params = data.getParameters();
        int oldResultsPerPage = params.getInt("oldResultsPerPage");
        int newResultsPerPage = params.getInt("resultsPerPage");
        int oldPageNum = params.getInt("pageNum");
        
        //
        // We want to display whichever page contains the first issue
        // on the old page.
        //
        int firstItem = (oldPageNum - 1) * oldResultsPerPage + 1;
        int newPageNum = (firstItem / newResultsPerPage) + 1;
        params.remove("oldResultsPerPage");
        params.remove("pageNum");
        params.add("pageNum", newPageNum);
        setTarget(data, getCurrentTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
protected boolean isAuthorized(RunData data) throws Exception
    {
        boolean auth = false;
        String perm = getRequiredPermission(data);
        TemplateContext context = getTemplateContext(data);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module currentModule = scarabR.getCurrentModule();
        ScarabUser user = (ScarabUser)data.getUser();

        if (ScarabSecurity.NONE.equals(perm)) 
        {
            if (!user.hasLoggedIn()) 
            {
                scarabR.setInfoMessage(L10NKeySet.LoginToAccountWithPermissions);
                Default.setTargetLogin(data);
                scarabR.setCurrentModule(null);
            }
            else 
            {
                auth = true;
            }
        }
        else if (perm == null)
        {
            scarabR.setAlertMessage(L10NKeySet.ActionNotAssignedPermission);
        }
        else
        {
            if (currentModule == null)
            {
                scarabR.setInfoMessage(L10NKeySet.SelectModuleToWorkIn);
                Default.setTargetSelectModule(data);
            }
            else if (! user.hasLoggedIn() 
                || !user.hasPermission(perm, currentModule))
            {
                scarabR.setInfoMessage(L10NKeySet.LoginToAccountWithPermissions);

                Default.setTargetLogin(data);
                scarabR.setCurrentModule(null);
            }
            else 
            {
                auth = true;
            }
        }
        return auth;
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doGonext(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getNextTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doGotoothertemplate(RunData data, 
                                     TemplateContext context)
        throws Exception
    {
        data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE,
                                       getCurrentTemplate(data));
        setTarget(data, getOtherTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doRefresh(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getCurrentTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doRefreshresultsperpage(RunData data, TemplateContext context) 
        throws Exception
    {
        ParameterParser params = data.getParameters();
        int oldResultsPerPage = params.getInt("oldResultsPerPage");
        int newResultsPerPage = params.getInt("resultsPerPage");
        int oldPageNum = params.getInt("pageNum");
        
        //
        // We want to display whichever page contains the first issue
        // on the old page.
        //
        int firstItem = (oldPageNum - 1) * oldResultsPerPage + 1;
        int newPageNum = (firstItem / newResultsPerPage) + 1;
        params.remove("oldResultsPerPage");
        params.remove("pageNum");
        params.add("pageNum", newPageNum);
        setTarget(data, getCurrentTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doReset(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        intake.removeAll();
        setTarget(data, getCurrentTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doCancel(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, getCancelTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        doSave(data, context);
        doCancel(data, context);
    }
            
// in java/org/tigris/scarab/actions/base/RequireLoginFirstAction.java
public boolean areThereDupeSequences(List list, IntakeTool intake,
               String groupName, String fieldName, int dedupeSeq)
        throws Exception
    {
        boolean dupeSequenceFound = false;
        int listSize = (list==null)?0:list.size();
        Field order1 = null;
        Field order2 = null;
        for (int i = 0; i < listSize && !dupeSequenceFound; i++)
        {
            Retrievable obj1 = (Retrievable)list.get(i);
            Group group1 = intake.get(groupName,obj1.getQueryKey(),false);
            order1 = group1.get(fieldName);

            if (dedupeSeq > 0 && order1.toString().equals(
                                          Integer.toString(dedupeSeq)))
            {
                dupeSequenceFound = true;
            }

            for (int j = i - 1; j >= 0 && !dupeSequenceFound; j--)
            {
                Retrievable obj2 = (Retrievable)list.get(j);
                Group group2 = intake.get(groupName,obj2.getQueryKey(),
                                             false);
                order2 = group2.get(fieldName);
                if (order1.toString().equals(order2.toString()))
                {
                    dupeSequenceFound = true;
                }
            }
        }
        return dupeSequenceFound;
    }
            
// in java/org/tigris/scarab/actions/base/BaseModifyIssue.java
protected boolean isCollision(RunData data, TemplateContext context)
        throws Exception
    {
        boolean isCollision = false;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        long modTimestamp = data.getParameters().getLong("mod_ts");

        String id = data.getParameters().getString("id");
        if (id == null) 
        {
            List issues = scarabR.getIssues();
            List conflictIssues = new ArrayList(issues.size());
            Iterator iter = issues.iterator();
            while (iter.hasNext()) 
            {
                Issue issue = (Issue)iter.next();
                long lastModTime = issue.getModifiedDate().getTime();
                boolean isSingleCollision = modTimestamp < lastModTime;
                if (isSingleCollision) 
                {
                    isCollision = true;
                    scarabR.setAlertMessage(
                        l10n.get("MultiIssueChangeCollision"));
                    ActivitySet lastActivitySet = issue.getLastActivitySet();
                    ArrayList objs = new ArrayList(2);
                    objs.add(issue);
                    objs.add(lastActivitySet);
                    conflictIssues.add(objs);
                }
            }
            context.put("lastActivities", conflictIssues);
        }
        else
        {
            Issue issue = IssueManager.getIssueById(id);
            List conflictIssues = new ArrayList(1);
            long lastModTime = issue.getModifiedDate().getTime();
            isCollision = modTimestamp < lastModTime;
            if (isCollision) 
            {
                scarabR.setAlertMessage(l10n.get("IssueChangeCollision"));
                ActivitySet lastActivitySet = issue.getLastActivitySet();
                ArrayList objs = new ArrayList(2);
                objs.add(issue);
                objs.add(lastActivitySet);
                conflictIssues.add(objs);
                context.put("lastActivities", conflictIssues);
            }
        }        
        return isCollision;
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doCheckforduplicates(data, context);
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
private boolean checkIssueTypeStatus(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getReportingIssue();
        Module module = issue.getModule();
        IssueType issueType = issue.getIssueType();
        boolean isValid = module != null && !module.getDeleted() &&
            issueType != null;
        if (isValid)
        {
            RModuleIssueType rmit = module.getRModuleIssueType(issueType);
            isValid = rmit != null && rmit.getActive();
        }

        if (!isValid)
        {
          scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
          data.setTarget( ((ScarabUser)data.getUser()).getHomePage());
          cleanup(data, context);
        }
        return isValid;
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doCheckforduplicates(RunData data, TemplateContext context)
        throws Exception
    {
        if (checkIssueTypeStatus(data, context))
        {
            checkForDuplicates(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void checkForDuplicates(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        try
        {
            Issue issue = scarabR.getReportingIssue();
            LinkedMap avMap = issue.getModuleAttributeValuesMap();

            // set the values entered so far and if that is successful look
            // for duplicates
            if (setAttributeValues(issue, intake, context, avMap))
            {
                // check for duplicates, if there are none skip the dedupe page
                searchAndSetTemplate(data, context, 0, MAX_RESULTS, issue,
                                     "entry,Wizard3.vm");
            }
        }
        catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }

        // we know we started at Wizard1 if we are here, Wizard3 needs
        // to know where the issue entry process starts because it may
        // branch back
        data.getParameters()
            .add(ScarabConstants.HISTORY_SCREEN, "entry,Wizard1.vm");
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
private boolean searchAndSetTemplate(RunData data,
                                         TemplateContext context,
                                         int threshold,
                                         int maxResults,
                                         Issue issue,
                                         String nextTemplate)
        throws Exception
    {
        // if all of the attributes are unset, then we don't need to run
        // this query...just break out of it early...
        List attributeValues = issue.getAttributeValues();
        boolean hasSetValues = false;
        for (Iterator itr = attributeValues.iterator();
             itr.hasNext() && !hasSetValues;) 
        {
            AttributeValue attVal = (AttributeValue) itr.next();
            hasSetValues = attVal.isSet();
        }
        if (!hasSetValues)
        {
            setTarget(data, nextTemplate);
            return true;
        }

        String template = null;
        boolean dupThresholdExceeded = false;
        IssueSearch duplicateSearch = IssueSearchFactory.INSTANCE.getInstance(issue, (ScarabUser)data.getUser());
        duplicateSearch.setLocalizationTool(getLocalizationTool(context));
        
        List possibleDuplicates = duplicateSearch.getQueryResults();
        dupThresholdExceeded = possibleDuplicates.size() > threshold;
        if (dupThresholdExceeded)
        {
            List possibleDuplicateIds = new ArrayList(maxResults);
            Iterator resultsIterator = possibleDuplicates.iterator();

            for (int i = 0; resultsIterator.hasNext() && i <= maxResults; i++) 
            {
                possibleDuplicateIds.add(((QueryResult)resultsIterator.next()).getUniqueId());
            }
            context.put("issueList", possibleDuplicateIds);
            template = "entry,Wizard2.vm";
        }
        else
        {
            template = nextTemplate;
        }
        
        setTarget(data, template);
        return dupThresholdExceeded;
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
private void setRequiredFlags(Issue issue, IntakeTool intake,
    		LinkedMap avMap, TemplateContext context)
        throws Exception
    {
        if (issue == null)
        {
            ScarabLocalizationTool l10n = getLocalizationTool(context);
            throw new Exception(l10n.get("IssueNoLongerValid")); //EXCEPTION
        }
        Set selectedOptions = new HashSet();
        Map conditionallyRequiredFields = new HashMap(); 
        IssueType issueType = issue.getIssueType();
        List requiredAttributes = issueType
            .getRequiredAttributes(issue.getModule());
        for (MapIterator iter = avMap.mapIterator(); iter.hasNext();)
        {
            AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            
            Group group = 
                intake.get("AttributeValue", aval.getQueryKey(), false);
            if (group != null) 
            {            
                Field field = null;
                if (aval instanceof OptionAttribute) 
                {
                    field = group.get("OptionId");
                    // Will store the selected optionId, for later query.
                    Object fieldValue = field.getValue();
                    if (null != fieldValue)
                    {
                        selectedOptions.add(fieldValue);
                    }                    
                }
                else if (aval instanceof IntegerAttribute) 
                {
                    field = group.get("NumericValue");
                }
                else if (aval instanceof UserAttribute) 
                {
                    field = group.get("UserId");
                }
                else 
                {
                    field = group.get("Value");
                }

                /**
                 * If the field has any conditional constraint, will be added to the collection
                 * in the hash.
                 */ 
                List conditions = aval.getRModuleAttribute().getConditions(); 
                if (conditions.size() > 0)
                {
                    for (Iterator it = conditions.iterator(); it.hasNext(); )
                    {
                        Condition cond = (Condition)it.next();
                        Integer id = cond.getOptionId();
                        List fields = (List)conditionallyRequiredFields.get(id);
                        if (fields == null)
                        {
                            fields = new ArrayList();
                        }
                        fields.add(field);
                        conditionallyRequiredFields.put(id, fields);
                    }
                }                
                
                for (int j=requiredAttributes.size()-1; j>=0; j--) 
                {
                    if (aval.getAttribute().getPrimaryKey().equals(
                            ((Attribute)requiredAttributes.get(j)).getPrimaryKey())
                        && !aval.isSet())
                    {
                        field.setRequired(true);
                        break;
                    }                    
                }
            }
        }
        /**
         * Now that we have all the info, we will force the 'required' status of any field
         * whose requiredOptionId has been set in the issue.
         */
        for (Iterator requiredIds = conditionallyRequiredFields.keySet().iterator(); requiredIds.hasNext(); )
        {
            Integer attributeId= (Integer)requiredIds.next();
            if (selectedOptions.contains(attributeId))
            {
                List fields = (List)conditionallyRequiredFields.get(attributeId);
                for (Iterator iter = fields.iterator(); iter.hasNext(); )
                {
                    Field field = (Field)iter.next();
            	    if (field.getValue().toString().length() == 0)
            	    {
            	       field.setRequired(true);
            	       field.setMessage("ConditionallyRequiredAttribute");
            	    }
                }
            }
        }        
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
private boolean setAttributeValues(Issue issue, IntakeTool intake, 
                                       TemplateContext context,
                                       LinkedMap avMap)
        throws Exception
    {
        boolean success = false;
        // set any required flags on attribute values
        setRequiredFlags(issue, intake, avMap, context);
        if (intake.isAllValid()) 
        {
            for (MapIterator i = avMap.mapIterator();i.hasNext();) 
            {
                AttributeValue aval = (AttributeValue)avMap.get(i.next());
                Group group = 
                    intake.get("AttributeValue", aval.getQueryKey(), false);
                if (group != null) 
                {
                	
                    Field field = null;
                    if(aval instanceof OptionAttribute){
                    	field = group.get("OptionId");
                    }
                    else if(aval instanceof IntegerAttribute){
                    	field = group.get("NumericValue");
                    } 
                    else{
                    	field = group.get("Value");
                    }
                    	
                    String value = field.toString();

                    if (value != null && value.length() > 0)
                    {
                        group.setProperties(aval);
                    }
                }
            }
            success = true;
        }
        else
        {
            getScarabRequestTool(context).setAlertMessage(ERROR_MESSAGE);
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doEnterissue(RunData data, TemplateContext context)
        throws Exception
    {
        if (checkIssueTypeStatus(data, context))
        {
            enterIssue(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
private void enterIssue(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getReportingIssue();
        ScarabUser user = (ScarabUser)data.getUser();
        LinkedMap avMap = issue.getModuleAttributeValuesMap(); 

        // set the attribute values and if that was successful save the issue.
        if (setAttributeValues(issue, intake, context, avMap))
        {
            DateAttribute.convertDateAttributes(issue.getAttributeValues(), getLocalizationTool(context).get("ShortDatePattern"));
            if (issue.containsMinimumAttributeValues())
            {
                // we need to see that the default text was filled out 
                // if necessary.  We can
                // only do this after setting the attributes above.
                boolean saveIssue = true;
                Group reasonGroup = intake.get("Attachment", "_1", false);
                Field reasonField = reasonGroup.get("Data");
                if (issue.getDefaultTextAttributeValue() == null)
                {
                    reasonField.setRequired(true);
                    saveIssue = false;
                }

                // if the reason field is to long, then show an error.
                String reasonString = reasonField.toString();
                if (reasonString != null && reasonString.length() > 254)
                {
                    reasonField.setMessage("intake_ReasonMustBeLessThan256Characters");
                    saveIssue = false;
                }
                // If there is a default text attribute,or if a comment has 
                // Been provided, proceed.
                if (reasonField.isValid() || saveIssue)
                {
                    HashMap newValues = new HashMap();
                    List modAttrs = issue.getModule()
                        .getRModuleAttributes(issue.getIssueType(), true, "all");

                    boolean foundLocalFieldErrors = false;
                    
                    // this is used for the workflow stuff...FIXME: it should
                    // be refactored as soon as we possibly can. the reason is
                    // that all of this data can be retrieved by simply using
                    // issue.getModuleAttributeValuesMap() because the call
                    // to setAttributeValues() above already gets the group
                    // information into the module attribute values.
                    for (int i = 0; i<modAttrs.size(); i++)
                    {
                        Attribute attr = ((RModuleAttribute)modAttrs.get(i)).getAttribute();
                        String queryKey = "__" + attr.getAttributeId().toString();
                        Group group = intake.get("AttributeValue", queryKey, false);
                        String newValue = "";

                        if (group != null) 
                        {
                            Field field = null;
                            if (attr.isOptionAttribute())
                            {
                                field = group.get("OptionId");
                            }
                            else 
                            {
                                field    = group.get("Value");
                            }
                            newValue = field.toString();

                            if (newValue.length() != 0)
                            {
                                String pattern = attr.getFormat();
                                String hint    = attr.getHint();
                                boolean exactMatch = true;
                                if(pattern != null && pattern.length()>0)
                                {
                                    RegexProcessor processor = new RegexProcessor();
                                    exactMatch = processor.matches(newValue, pattern);
                                }
                                if(exactMatch)
                                {
                                    newValues.put(attr.getAttributeId(), newValue);
                                }
                                else
                                {                                                                      
                                    String[] parameters = new String[]{attr.getName(), newValue, pattern, hint};
                                    LocalizationKey key;
                                    if(newValue.equals(hint))
                                    {
                                        key = L10NKeySet.UnprocessedField;
                                    }
                                    else
                                    {
                                        key = L10NKeySet.InvalidFieldFormat;
                                    }
                                    L10NMessage l10nMessage = new L10NMessage(key, parameters);
                                    field.setMessage(l10nMessage.getMessage(l10n));
                                    foundLocalFieldErrors = true;
                                }
                            }
                        }
                    }
                    
                    
                    if (foundLocalFieldErrors) 
                    {
                        scarabR.setAlertMessage(ERROR_MESSAGE);
                        // were obviously in editing mode
                        data.getParameters().add("edit_attributes", "true");
                        // preserve fullcomments mode
                        data.getParameters().add("fullcomments", data.getParameters().get("fullcomments"));
                        return;
                    }
                    
                    
                    
                    // Save the Reason
                    ActivitySet activitySet = null;
                    Attachment reason = null;
                    try
                    {
                        // grab the comment data
                        reason = new Attachment();
                        reasonField.setProperty(reason);
                        activitySet = issue
                            .setInitialAttributeValues(activitySet, reason, newValues, user);
                    }
                    catch (Exception se)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        return;
                    }

                    // Save any unsaved attachments as part of this ActivitySet as well
                    activitySet = issue.doSaveFileAttachments(activitySet, user);

                    // set the template to the user selected value
                    int templateCode = data.getParameters()
                        .getInt("template_code", 2);
                
                    // if user preference for next template is unset,
                    // set it.
                    int userPref = user.getEnterIssueRedirect();
                    if (userPref == 0 || userPref != templateCode)
                    {
                        user.setEnterIssueRedirect(templateCode);
                    }
                    doRedirect(data, context, templateCode, issue);
                
                    NotificationManagerFactory.getInstance()
                            .addActivityNotification(
                                    ActivityType.ISSUE_CREATED,
                                    activitySet, issue, user);                        

                    String assignActiveUser = data.getParameters().get("add_user");
                    if(assignActiveUser != null && assignActiveUser.length() > 0)
                    {                      
                        // Lets cross-call the AssignIssue Turbine action!
                        AssignIssue assignAction = new AssignIssue();
                        assignAction.doAdd(data, context);
                        assignAction.doSave(data, context);
                    }
                  
                    String assignWatcherUser = data.getParameters().get("add_watcher");
                    if(assignWatcherUser != null && assignWatcherUser.length() > 0)
                    {
                        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                            issue.getModule()))
                        {
                            // We'll set the info required by AssignIssue.doAddmyself (the)
                            // same that in doEditassignees in this same class.
                            data.getParameters().add("id", issue.getUniqueId());
                            data.getParameters().add("issue_ids", issue.getUniqueId());
                            String watcher = data.getParameters().get("add_watcher");
                            data.getParameters().remove("add_user");
                            data.getParameters().add("add_user", watcher);
                
                            scarabR.resetAssociatedUsers();
                            
                            // Lets cross-call the AssignIssue Turbine action!
                            AssignIssue assignAction = new AssignIssue();
                            assignAction.doAdd(data, context);
                            assignAction.doSave(data, context);
                        }
                        else
                        {
                            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                        }
                    }
                  
                  
                    cleanup(data, context);
                    data.getParameters().add("id", issue.getUniqueId().toString());
                    L10NMessage l10nMessage = 
                        new L10NMessage(L10NKeySet.IssueAddedToModule,
                            issue.getUniqueId(), 
                            getScarabRequestTool(context).getCurrentModule().getRealName());
                    scarabR.setConfirmMessage(l10nMessage);
                }
                else
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                }
            }
            else 
            {
                // this would be an application or hacking error
            }
        }
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doAddfile(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getReportingIssue();
        Attachment attachment = AttachmentManager.getInstance();
        Group group = intake.get("Attachment", 
                                 attachment.getQueryKey(), false);

        ModifyIssue
            .addFileAttachment(issue, group, attachment, scarabR, data, intake);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (scarabR.getAlertMessage() == null)
        {
            scarabR.setConfirmMessage(L10NKeySet.FileAdded);
        }

        LinkedMap avMap = issue.getModuleAttributeValuesMap(); 
        // set any attribute values that were entered before adding the file.
        setAttributeValues(issue, intake, context, avMap);
        doGotowizard3(data, context);
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doRemovefile(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getReportingIssue();
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String attachmentIndex;
        boolean fileDeleted = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("file_delete_"))
            {
                attachmentIndex = key.substring(12);
                issue.removeFile(attachmentIndex);
                fileDeleted = true;
            }
        }
        if (fileDeleted)
        {
            scarabR.setConfirmMessage(L10NKeySet.FileDeleted);
        }
        else
        {
            scarabR.setConfirmMessage(L10NKeySet.NoFilesChanged);
        }
        LinkedMap avMap = issue.getModuleAttributeValuesMap(); 
        // set any attribute values that were entered before adding the file.
        setAttributeValues(issue, getIntakeTool(context), context, avMap);
        doGotowizard3(data, context);
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doAddcomment(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IntakeTool intake = getIntakeTool(context);        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getReportingIssue();
        if (intake.isAllValid())
        {
            Attachment attachment = new Attachment();
            Group group = intake.get("Attachment", 
                          attachment.getQueryKey(), false);
            if (group != null)
            {
                 List issues = scarabR.getIssues();
                 if (issues == null || issues.size() == 0)
                 {
                     scarabR.setAlertMessage(L10NKeySet.NoIssuesSelectedToAddComment);
                     searchAndSetTemplate(data, context, 0, MAX_RESULTS, issue, "entry,Wizard2.vm");
                     return;
                 }
                 ActivitySet activitySet = null;
                 for (Iterator itr = issues.iterator(); itr.hasNext();)
                 {
                     Issue prevIssue = (Issue)itr.next();
                     // save the attachment
                     attachment = new Attachment();
                     group.setProperties(attachment);
                     if (attachment.getData() != null 
                         && attachment.getData().trim().length() > 0)
                     {
                         ScarabUser user = (ScarabUser)data.getUser();
                          activitySet = 
                             prevIssue.addComment(activitySet, attachment, user);
                          NotificationManagerFactory.getInstance()
                                .addActivityNotification(
                                        ActivityType.COMMENT_ADDED,
                                        activitySet, issue, null, null, user);                              
                          scarabR.setConfirmMessage(L10NKeySet.CommentAdded);
                     }
                    else
                    {
                        scarabR.setAlertMessage(
                           L10NKeySet.NoTextInCommentTextArea);
                        searchAndSetTemplate(data, context, 0, MAX_RESULTS,
                                             issue, "entry,Wizard2.vm");
                        return;
                    }
                }
            }

            // if there was only one duplicate issue and we just added
            // a comment to it, assume user is done
            String nextTemplate = 
                 ((ScarabUser)data.getUser()).getHomePage();
            if (! searchAndSetTemplate(data, context, 1, MAX_RESULTS, issue, nextTemplate))
            {
                cleanup(data, context);
            }
            else
            {
                intake.remove(group);
            }
            return;
        }
        else 
        {
            // Comment was probably too long.  Repopulate the issue list, so
            // the page can be shown again, and the user can fix the comment.
            searchAndSetTemplate(data, context, 0, MAX_RESULTS, issue, "entry,Wizard2.vm");
        }
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doGotowizard3(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "entry,Wizard3.vm");
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doUsetemplates(RunData data, TemplateContext context)
        throws Exception
    {
        getIntakeTool(context).removeAll();
        String templateId = data.getParameters().getString("select_template_id");
        if (templateId != null && templateId.length() > 0)
        {
            data.getParameters().add("templateId", templateId);
        }
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
private void doRedirect(RunData data, TemplateContext context, 
                            int templateCode, Issue issue)
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String template = null;
        switch (templateCode)
        {
            case 1: 
                if (user.hasPermission(ScarabSecurity.ISSUE__ENTER, 
                                       user.getCurrentModule()))
                {
                    IssueType issueType = issue.getIssueType();
                    template = scarabR.getNextEntryTemplate(issueType);
                    data.getParameters().setString(
                        ScarabConstants.CURRENT_ISSUE_TYPE, 
                        issueType.getQueryKey());
                }
                else 
                {
                    template = user.getHomePage();
                    scarabR.setAlertMessage(
                        L10NKeySet.InsufficientPermissionsToEnterIssues);
                }
                break;
            case 2: 
                if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                                       user.getCurrentModule()))
                {
                    template = "AssignIssue.vm";
                    data.getParameters().setString(ScarabConstants.CANCEL_TEMPLATE, 
                                             "ViewIssue.vm");
                    data.getParameters().add("issue_ids", 
                                             issue.getUniqueId());
//                    data.getParameters()
//                        .setString("id", issue.getUniqueId().toString());
                    getIntakeTool(context).removeAll();
                    scarabR.resetAssociatedUsers();
                }
                else 
                {
                    template = user.getHomePage();
                    scarabR.setAlertMessage(
                        L10NKeySet.InsufficientPermissionsToAssignIssues);
                }
                break;
            case 3: 
                if (user.hasPermission(ScarabSecurity.ISSUE__VIEW, 
                                       user.getCurrentModule()))
                {
                    template = "ViewIssue.vm";
                    data.getParameters()
                        .setString("id",issue.getUniqueId().toString());
                }
                else 
                {
                    template = user.getHomePage();
                    scarabR.setAlertMessage(
                        L10NKeySet.InsufficientPermissionsToViewIssues);
                }
                break;
            case 4: 
                template = user.getHomePage();
                break;
            case 5: 
                if (user.hasPermission(ScarabSecurity.ISSUE__VIEW, 
                                       user.getCurrentModule()))
                {
                    template = "ViewIssue.vm";
                    data.getParameters()
                        .setString("id",issue.getUniqueId().toString());
                    data.getParameters()
                        .setString("tab","3"); // comment tab == 3
                    data.getUser().setTemp(ScarabConstants.TAB_KEY, "3");
                }
                else 
                {
                    template = user.getHomePage();
                    scarabR.setAlertMessage(
                        L10NKeySet.InsufficientPermissionsToViewIssues);
                }
                break;
        } 
        setTarget(data, template);
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
public void doStart(RunData data, TemplateContext context)
        throws Exception
    {
        cleanOutStaleIssue(data, context);
    }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
static void cleanOutStaleIssue(RunData data, TemplateContext context)
        throws Exception
    {
        String key = data.getParameters()
            .getString(ScarabConstants.REPORTING_ISSUE);
        ScarabUser user = (ScarabUser)data.getUser();
        if (key != null) 
        {
            data.getParameters().remove(ScarabConstants.REPORTING_ISSUE);
            user.setReportingIssue(key, null);
        }
        //user.setHomePage("home,EnterNew.vm");
    }
            
// in java/org/tigris/scarab/actions/SetHomePage.java
public void doPerform(RunData data, TemplateContext context) throws Exception
    {
        String target = data.getTarget();
        //TODO [HD] Maybe this hard coded reference shall be 
        //          parametrized at some day. (refactoring candidate).
        if ("ModuleNotReady.vm".equals(target)) 
        {
            Log.get()
                .debug("Setting homepage to ModuleNotReady.vm was avoided");
        }
        else 
        {
            ((ScarabUser)data.getUser()).setHomePage(target);
        }
    }
            
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
public void doRequestroles(RunData data, TemplateContext context)
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        ScarabUser user = (ScarabUser)data.getUser();
        SecurityAdminTool scarabA = getSecurityAdminTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);

        // List roles = scarabA.getNonRootRoles();
        List groups = Arrays.asList(scarabA.getGroups());

        Iterator gi = groups.iterator();

        String autoApproveRoleSet=null;
        String waitApproveRoleSet=null;
        
        while (gi.hasNext()) 
        {
            ScarabModule module = ((ScarabModule)gi.next());
            String[] autoRoles = module.getAutoApprovedRoles();
            String roleName = data.getParameters().getString(module.getModuleId().toString());
            AccessControlList acl = user.getACL();
            Role requiredRoleForRequests = module.getRequiredRole();
            boolean bRoleRequestable = requiredRoleForRequests == null || acl.hasRole(requiredRoleForRequests, module);
            if (roleName != null && roleName.length() > 0 && bRoleRequestable) 
            {
                boolean autoApprove = Arrays.asList(autoRoles).contains(roleName);
                if (autoApprove) 
                {
                    Role role = TurbineSecurity.getRole(roleName);
                    
                    TurbineSecurity.grant(user, module, role);

                    // TODO: Needs to be refactored into the Users system?
                    ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.GET_ACL);
                    ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable)role, module);

                    autoApproveRoleSet = addToRoleSet(autoApproveRoleSet,module, roleName);
                }
                else 
                {
                    deleteRoleRequests(user, module);
                    // '0' role really means 'remove request' from module
                    if (!roleName.equals("0"))
                    {
                        try
                        {
                            sendNotification(module, user, roleName); 
                        }
                        catch(Exception e)
                        {
                            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.CouldNotSendNotification,e);
                            scarabR.setAlertMessage(l10nMessage);
                        } 
                        PendingGroupUserRole pend = new PendingGroupUserRole();
                        pend.setGroupId(module.getModuleId());
                        pend.setUserId(user.getUserId());
                        pend.setRoleName(roleName);
                        pend.save();
                        waitApproveRoleSet = addToRoleSet(waitApproveRoleSet,module, roleName);
                    }
                }                
            }
        }

        if (autoApproveRoleSet != null)
        {
            SimpleSkipFiltering htmlSet = new SimpleSkipFiltering(autoApproveRoleSet+"<br>");
            Localizable msg = new L10NMessage(L10NKeySet.RoleRequestGranted, htmlSet);
            scarabR.setConfirmMessage(msg);                    
        }

        if (waitApproveRoleSet != null)
        {
            SimpleSkipFiltering htmlSet = new SimpleSkipFiltering(waitApproveRoleSet+"<br>");
            Localizable msg = new L10NMessage(L10NKeySet.RoleRequestAwaiting, htmlSet);
            scarabR.setInfoMessage(msg);                    
        }

        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
private void sendNotification(ScarabModule module, ScarabUser user, 
                                  String role)
        throws Exception
    {
        EmailContext econtext = new EmailContext();

        econtext.setModule(module);
        econtext.setUser(user);
        econtext.put("role", role);
                
        // Who can approve this request?
        List approvers = Arrays.asList(module.
            getUsers(ScarabSecurity.USER__APPROVE_ROLES));

        // Which potential approvers has any role in this module?
        List approversWithRole = new ArrayList();
        for(Iterator i = approvers.iterator(); i.hasNext();)
        {
            ScarabUser u = (ScarabUser)i.next();
            if (u.hasAnyRoleIn(module))
            {
                approversWithRole.add(u);
            }
        }

        // If some approvers have role in this module, sent email only to them.
        if (!approversWithRole.isEmpty())
        {
            approvers = approversWithRole;
        }

        Email.sendEmail(econtext, module, 
                               "scarab.email.default", module.getSystemEmail(),
                               approvers, null,
                               "RoleRequest.vm");        
    }
            
// in java/org/tigris/scarab/actions/admin/AppConfigurationSettings.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        boolean customSettingsChanged = false;
        ParameterParser pp = data.getParameters();
        CompositeConfiguration c = (CompositeConfiguration)Turbine.getConfiguration();
        PropertiesConfiguration customSettings =null;
        for (int i = 0;i<c.getNumberOfConfigurations();i++){
            if(c.getConfiguration(i) instanceof PropertiesConfiguration){
                PropertiesConfiguration pc = (PropertiesConfiguration)c.getConfiguration(i);
                if(pc.getFileName().endsWith("custom.properties")){
                    customSettings = pc;
                    break;
                }
            }
        }
 
        if (customSettings==null){
            throw new Exception("custom.properties file was not defined in TurbineConfiguration.xml");
        }
                
        for (Iterator i =
            IteratorUtils.filteredIterator(
                new EnumerationIterator(pp.keys()),
                new StartsWithPredicate("configuration.key."));
            i.hasNext();
            )
        {
            String key = (String) i.next();
            String realKey = pp.getString(key);
            String value = pp.getString("configuration.value." + realKey);
            
            String turbineValue;
            try
            {
            	turbineValue = Turbine.getConfiguration().getString(realKey);
            }
            catch( ConversionException ce)
            {
            	// This happens, if the Turbine Property is not a String.
            	// This has been seen on JBOSS. Since we can't provide any
            	// reasonable value here, ignore the entry and continue.
            	log.warn("Turbine property ["+realKey+"] is not a String value. No update done. (continue)");
            	turbineValue = null;
            }            
            
            if (turbineValue != null && !turbineValue.equals(value))
            {
                Turbine.getConfiguration().setProperty(realKey,value);                
                customSettings.setProperty(realKey,value);
                customSettingsChanged=true;                
            }
            
        }
        if (customSettingsChanged){
            customSettings.save();
        }
        
        
        getScarabRequestTool(context).setConfirmMessage(L10NKeySet.AppConfigurationChangesSaved);
    }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
public void doSubmit(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = (ScarabRequestTool)context
            .get(ScarabConstants.SCARAB_REQUEST_TOOL);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Module module = scarabR.getCurrentModule();
        String globalComment = data.getParameters().getString("global_comment");
       
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String action = null;
        Integer actionWord = null;
        Integer artifact = null;
        String artifactName = null;
        String comment = null;
        ScarabUser toUser = null;
        String userId;
        boolean success = true;

        for (int i =0; i<keys.length; i++)
        {
            action="none";
            key = keys[i].toString();
            if (key.startsWith("query_id_"))
            {
               String queryId = key.substring(9);
               Query query = QueryPeer.retrieveByPK(new NumberKey(queryId));

               action = params.getString("query_action_" + queryId);
               comment = params.getString("query_comment_" + queryId);

               userId = params.getString("query_user_" + queryId);
               toUser = scarabR.getUser(userId);
               artifact = QUERY;
               artifactName = query.getName();

               if (query.getApproved())
               {
                   success = false;
                   boolean isApproved = Scope.MODULE__PK.equals(query.getScopeId());
                   LocalizationKey l10nKey = (isApproved) ?
                       L10NKeySet.ItemAlreadyApproved:L10NKeySet.ItemAlreadyRejected;
                   L10NMessage l10nMessage = new L10NMessage(l10nKey,artifactName);
                   scarabR.setAlertMessage(l10nMessage);
               }
               else
               {
                   if (action.equals(REJECT))
                   {
                       try
                       {
                           query.approve(user, false);
                       }
                       catch (ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                       actionWord = REJECTED;
                   } 
                   else if (action.equals(APPROVE))
                   {
                       try
                       {
                           query.approve(user, true);
                       }
                       catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                       actionWord = APPROVED;
                       }
                       else if (action.equals(COMMENT))
                       {
                           actionWord = COMMENTED; 
                       }
                   }
               }
               else if (key.startsWith("template_id_"))
               {
                   String templateId = key.substring(12);
                   IssueTemplateInfo info = IssueTemplateInfoPeer
                                     .retrieveByPK(new NumberKey(templateId));

               action = params.getString("template_action_" + templateId);
               comment = params.getString("template_comment_" + templateId);

               userId = params.getString("template_user_" + templateId);
               toUser = scarabR.getUser(userId);
               artifact = ISSUE_ENTRY_TEMPLATE;
               artifactName = info.getName();

               if (info.getApproved())
               {
                   success = false;
                   boolean isApproved = Scope.MODULE__PK.equals(info.getScopeId());
                   LocalizationKey l10nKey = (isApproved) ?
                       L10NKeySet.ItemAlreadyApproved:L10NKeySet.ItemAlreadyRejected;
                   L10NMessage l10nMessage = new L10NMessage(l10nKey,artifactName);
                   scarabR.setAlertMessage(l10nMessage);
               }
               else
               {
                   if (action.equals(REJECT))
                   {
                       try
                       {
                           info.approve(user, false);
                       }
                       catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                       actionWord = REJECTED;
                   } 
                   else if (action.equals(APPROVE))
                   {
                       try
                       {
                           info.approve(user, true);
                       }
                       catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
                       actionWord = APPROVED;
                   }
                   else if (action.equals(COMMENT))
                   {
                       actionWord = COMMENTED;
                   }
                }
                if (!action.equals("none") && success)
                {
                    // send email
                    EmailContext ectx = new EmailContext();
                    ectx.setUser(user);
                    // add specific data to context for email template
                    ectx.put("artifactIndex", artifact);
                    ectx.put("artifactName", artifactName);
                    ectx.put("actionIndex", actionWord);
                    ectx.put("comment", comment);
                    ectx.put("globalComment", globalComment);

                    String template = Turbine.getConfiguration().
                        getString("scarab.email.approval.template",
                                  "Approval.vm");
                    try
                    {
                        Email.sendEmail(ectx, module, user, 
                                        module.getSystemEmail(), 
                                        toUser, template);
                    }
                    catch (Exception e)
                    {
                        L10NMessage l10nMessage =new L10NMessage(EMAIL_ERROR,e);
                        scarabR.setAlertMessage(l10nMessage);
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
public void doApproveroles(RunData data, TemplateContext context)
        throws Exception
    {
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module module = scarabR.getCurrentModule();
        if (((ScarabUser)data.getUser())
            .hasPermission(ScarabSecurity.USER__APPROVE_ROLES, module)) 
        {
            SecurityAdminTool scarabA = getSecurityAdminTool(context);
            List pendings = scarabA.getPendingGroupUserRoles(module);
            Iterator i = pendings.iterator();
            while (i.hasNext()) 
            {
                PendingGroupUserRole pending = (PendingGroupUserRole)i.next();
                ScarabUser user = 
                    ScarabUserManager.getInstance(pending.getUserId());

                String checked = data.getParameters()
                .getString("user_id_"+user.getUserName());

                if(checked != null && checked.equals("on"))
                {
                    String roleName = data.getParameters()
                        .getString(user.getUserName());
                    if (roleName != null && roleName.length() > 0) 
                    {
                        if (roleName.equalsIgnoreCase(l10n.get(L10NKeySet.Deny)))
                        {
                            pending.delete();
                        }
                        else 
                        {
                            Role role = TurbineSecurity.getRole(roleName);
                            try
                            {
                                TurbineSecurity.grant(user, (Group)module, role);

                                // TODO: Needs to be refactored into the Users system?
                                ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.GET_ACL);
                                ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable)role, module);
                            }
                            catch (DataBackendException e)
                            {
                                // maybe the role request was approved 
                                // by another admin?
                                AccessControlList acl = user.getACL();
                                if (acl.hasRole( role, (Group) module ) )
                                {
                                    String[] args = {roleName,
                                            user.getUserName(),
                                            module.getRealName()};
                                    String msg = l10n
                                            .format(
                                                    "RolePreviouslyApprovedForUserInModule",
                                                    args);
                                    String info = (String) scarabR
                                            .getInfoMessage();
                                    if (info == null)
                                    {
                                        info = msg;
                                    }
                                    else
                                    {
                                        info += " " + msg;
                                    }

                                    scarabR.setInfoMessage(info);
                                }
                                else
                                {
                                    throw e; //EXCEPTION
                                }
                            }
                            pending.delete();
                        }
                    }
                }
            }
            scarabR.setConfirmMessage(L10NKeySet.AllRolesProcessed);
        }
        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/admin/SetInfoMessage.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        String msg = data.getParameters().getString("msg");
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        if (msg == null || msg.trim().length() == 0) 
        {
            SetInfoMessageValve.setMessage(null);
            scarabR.setInfoMessage(null);
        }
        else 
        {
            SetInfoMessageValve.setMessage(msg);            
            scarabR.setInfoMessage(msg);
        }        
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public boolean doSaveinfo (RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return false;
        }
        IntakeTool intake = getIntakeTool(context);
        Module module = scarabR.getCurrentModule();
        RModuleIssueType rmit = module.getRModuleIssueType(issueType);
        if (rmit == null)
        {
            scarabR.setAlertMessage(L10NKeySet.IssueTypeRemovedFromModule);
            doCancel(data, context);
            return false;
        }
        // Set properties for module-issue type info
        Group rmitGroup = intake.get("RModuleIssueType",
                                        rmit.getQueryKey(), false);
        if (intake.isAllValid())
        {
            boolean nameTaken = false;
            List issueTypes = module.getRModuleIssueTypes();
            if (issueTypes != null)
            {
                Field displayName = rmitGroup.get("DisplayName");
                if (displayName.toString().trim().length() == 0)
                {
                    displayName.setMessage("intake_IssueTypeNameNotAllowedEmpty");
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    return false;
                }
                for (int i=0;i<issueTypes.size();i++)
                {
                    RModuleIssueType tmpRmit = ((RModuleIssueType)issueTypes.get(i));
                    if (tmpRmit.getDisplayName().equals(displayName.toString()) 
                        && !tmpRmit.getIssueTypeId().equals(issueType.getIssueTypeId()))
                    {
                        nameTaken = true;
                        break;
                    }
                }
            }
         
            if (nameTaken) 
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
                rmitGroup.get("DisplayName").setMessage("IssueTypeNameExists");
                return false;
            }
            else
            {
                rmitGroup.setProperties(rmit);
                rmit.save();
                scarabR.setConfirmMessage(DEFAULT_MSG);
            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
            return false;
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public boolean doSavegroups (RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return false;
        }

        Module module = scarabR.getCurrentModule();
        RModuleIssueType rmit = module.getRModuleIssueType(issueType);
        if (rmit == null)
        {
            scarabR.setAlertMessage(L10NKeySet.IssueTypeRemovedFromModule);
            doCancel(data, context);
            return false;
        }
        List attGroups = issueType.getAttributeGroups(module, false);

        int dupeOrder = 2;
        boolean areThereDedupeAttrs = false;

        // Manage attribute groups
        // Only have dedupe if there are more than one active group
        if (issueType.getAttributeGroups(module, true).size() > 1)
        {
            dupeOrder = data.getParameters().getInt("dupe_order");

            // Check that duplicate check is not at the beginning.
            if (dupeOrder == 1)
            {
                scarabR.setAlertMessage(L10NKeySet.CannotPositionDuplicateCheckFirst);
                return false;
            }
            // Check for duplicate sequence numbers
            if (areThereDupeSequences(attGroups, intake, "AttributeGroup",
                   "Order", dupeOrder))
            {
               scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                   l10n.get("AttributeGroups").toLowerCase()));
               return false;
            }
        }

        // Set properties for attribute groups
        for (int i=attGroups.size()-1; i>=0; i--)
        {
            AttributeGroup attGroup = (AttributeGroup)attGroups.get(i);
            Group agGroup = intake.get("AttributeGroup",
                                 attGroup.getQueryKey(), false);
            agGroup.setProperties(attGroup);

            // If an attribute group falls before the dedupe screen,
            // Mark it as a dedupe group
            if (attGroup.getOrder() < dupeOrder)
            {
                areThereDedupeAttrs = true;
                attGroup.setDedupe(true);
                List dedupeGroups = module.
                         getDedupeGroupsWithAttributes(issueType);
                if (!dedupeGroups.contains(attGroup))
                {
                    dedupeGroups.add(attGroup);
                }
            }
            else
            {
                attGroup.setDedupe(false);
            }
            attGroup.save();
        }

            // Set dedupe property for module-issueType
        if (!areThereDedupeAttrs
                || issueType.getAttributeGroups(module, true).size() < 2)
        {
            rmit.setDedupe(false);
        }
        else
        {
            Group rmitGroup = intake.get("RModuleIssueType",
                                        rmit.getQueryKey(), false);
            Field dedupe = rmitGroup.get("Dedupe");
            dedupe.setProperty(rmit);
        }
        rmit.save();
        ScarabCache.clear();
        scarabR.setConfirmMessage(DEFAULT_MSG);

        return true;
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public boolean doSaveuserattributes (RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        boolean success = true;

        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            success = false;
        }
        else if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            success = false;
        }
        else
        {
            Module module = scarabR.getCurrentModule();
            List rmas = module.getRModuleAttributes(issueType, false, "user");
            if (areThereDupeSequences(rmas, intake, "RModuleAttribute",
                                                             "Order", 0))
            {
                scarabR.setAlertMessage(
                    l10n.format("DuplicateSequenceNumbersFound",
                    l10n.get("UserAttributes").toLowerCase()));
                success = false;
            }
            else
            {
                for (Iterator itr = rmas.iterator(); itr.hasNext(); )
                {
                    // Set properties for module-attribute mapping
                    RModuleAttribute rma = (RModuleAttribute)itr.next();
                    Group rmaGroup = intake.get("RModuleAttribute",
                             rma.getQueryKey(), false);
                    // if attribute gets set to inactive, delete dependencies
                    boolean newActive = Boolean.valueOf(rmaGroup.get("Active").
                                                    toString()).booleanValue();
                    boolean oldActive = rma.getActive();
                    if (!newActive && oldActive)
                    {
                        WorkflowFactory.getInstance().
                            deleteWorkflowsForAttribute(
                                      rma.getAttribute(), module, issueType);
                    }
                    rmaGroup.setProperties(rma);
                    rma.save();
                }
                scarabR.setConfirmMessage(DEFAULT_MSG);
            }

        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public AttributeGroup doCreatenewgroup (RunData data, 
                                             TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module module = scarabR.getCurrentModule();
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return null;
        }
        scarabR.setConfirmMessage(DEFAULT_MSG);
        return issueType.createNewGroup(module);
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doDeletegroup (RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        boolean noAGSelected = true;
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }

        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String groupId;
        Module module = scarabR.getCurrentModule();
        List attributeGroups = issueType.getAttributeGroups(module, false);

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("group_action"))
            {
                try
                {
                    groupId = key.substring(13);
                    AttributeGroup ag = AttributeGroupManager
                       .getInstance(new NumberKey(groupId), false); 
                    ag.delete();
                    noAGSelected = false;
                    scarabR.setConfirmMessage(DEFAULT_MSG);  
                    ScarabCache.clear();
                    getIntakeTool(context).removeAll();
                }
                catch (Exception e)
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
                if (attributeGroups.size() -1 < 2)
                {
                    // If there are fewer than 2 attribute groups,
                    // Turn of deduping
                    RModuleIssueType rmit =  module.getRModuleIssueType(issueType);
                    rmit.setDedupe(false);
                    rmit.save();
                }
            }
        }
        if (noAGSelected)
        {
           scarabR.setAlertMessage(L10NKeySet.NoAttributeGroupSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doDeleteuserattribute(RunData data, TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        boolean hasAttributes = false;
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }
        Module module = scarabR.getCurrentModule();
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String attributeId;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("att_delete_"))
            {
               hasAttributes = true;
               attributeId = key.substring(11);
               Attribute attribute = AttributeManager
                   .getInstance(new NumberKey(attributeId), false);

               // Remove attribute - module mapping
               RModuleAttribute rma = module
                   .getRModuleAttribute(attribute, issueType);
               rma.delete();

               // Remove attribute - module mapping from template type
               RModuleAttribute rma2 = module
                   .getRModuleAttribute(attribute,
                   scarabR.getIssueType(issueType.getTemplateId().toString()));
               rma2.delete();
               scarabR.setConfirmMessage(DEFAULT_MSG);
               ScarabCache.clear();
           }
        }
        if(!hasAttributes)
        {
            scarabR.setAlertMessage(L10NKeySet.NoUserAttributeSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doCreatenewuserattribute(RunData data,
                                            TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        Group attGroup = intake.get("Attribute", IntakeTool.DEFAULT_KEY);
        intake.remove(attGroup);
        scarabR.setAttribute(null);
        setTarget(data, getOtherTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doSelectuserattribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }

        Module module = scarabR.getCurrentModule();
        String[] attributeIds = data.getParameters()
                                    .getStrings("attribute_ids");
 
        if (attributeIds == null || attributeIds.length <= 0)
        { 
            scarabR.setAlertMessage(L10NKeySet.SelectAttribute);
            return;
        }
        else
        {        
            for (int i=0; i < attributeIds.length; i++)
            {
                Attribute attribute = 
                    scarabR.getAttribute(new Integer(attributeIds[i]));
                if (attribute != null)
                {
                    // add module-attribute groupings
                    module.addRModuleAttribute(issueType,attribute);
                }
                doCancel(data, context);
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = doSaveinfo(data, context) &&
                              doSavegroups(data, context) &&
                                  doSaveuserattributes(data, context);
        if (success)
        {
            doCancel(data, context);
        }
        //Reset confirm message in case some of the changes got saved
        else
        {
            getScarabRequestTool(context).setConfirmMessage(null);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypes.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        List issueTypes = IssueTypePeer.getAllIssueTypes(false);
        boolean dupe = false;
        boolean saved = false;
        if (intake.isAllValid())
        {
            ScarabRequestTool scarabR = getScarabRequestTool(context);
            for (int i=0; i<issueTypes.size(); i++)
            {
                IssueType issueType = (IssueType)issueTypes.get(i);
                Group group = intake.get("IssueType", issueType.getQueryKey());
                // make sure name is unique
                Field field = group.get("Name");
                String name = field.toString();
                if (IssueTypePeer.isUnique(name, issueType.getIssueTypeId())) 
                {
                    group.setProperties(issueType);
                    issueType.save();
                    ScarabCache.clear();
                    saved = true;
                }
                else 
                {
                    dupe = true;
                    field.setMessage("Duplicate");
                }
            }
            if (dupe)
            {
                scarabR.setAlertMessage(
                    l10n.get("ChangesResultDuplicateNames"));
            }
            else if (saved)
            {
                scarabR.setConfirmMessage(
                    l10n.get(DEFAULT_MSG));
            }
            else
            {
                scarabR.setInfoMessage(
                    l10n.get(NO_CHANGES_MADE));
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypes.java
public void doCopy(RunData data, TemplateContext context)
        throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key;
        String id;
        IssueType issueType;
        boolean didCopy = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
                id = key.substring(7);
                issueType = IssueTypeManager.getInstance(new Integer(id));
                if (issueType != null)
                {
                    issueType.copyIssueType();
                    didCopy = true;
                }
            }
        }
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (didCopy)
        {
            scarabR.setConfirmMessage(l10n.get("GlobalArtifactTypeCopied"));
        }
        else
        {
            scarabR.setInfoMessage(l10n.get(NO_CHANGES_MADE));
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypes.java
public void doDelete(RunData data, TemplateContext context)
        throws Exception
    {
        String key = null;
        String id = null;
        IssueType issueType = null;
        boolean deleted = false;
        boolean hasIssues = false;
        boolean immutable = false;
        Object[] keys = data.getParameters().getKeys();
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IntakeTool intake = getIntakeTool(context);
        for (int i =0; i<keys.length; i++)
        {
             key = keys[i].toString();
             if (key.startsWith("action_"))
             {
                id = key.substring(7);
                issueType = IssueTypeManager.getInstance(new Integer(id));
                if (issueType != null)
                {
                    Group group = intake.get("IssueType", issueType.getQueryKey());
                    Field field = group.get("Name");
                    if (issueType.isSystemDefined())
                    {
                        field.setMessage("CannotDeleteSystemSpecifiedIssueType");
                        immutable = true;
                    }
                    else if (issueType.hasIssues())
                    {
                        field.setMessage("IssueTypeHasIssues");
                        hasIssues = true;
                    }
                    else
                    {
                        issueType.setDeleted(true);
                        issueType.save();
                        deleted = true;
                    }
                }
            }
        }
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        if (immutable)
        {
            scarabR.setAlertMessage(l10n.get("CannotDeleteSystemSpecifiedIssueType"));
        }
        else if (hasIssues)
        {
            scarabR.setAlertMessage(l10n.get("CannotDeleteIssueTypesWithIssues"));
        }
        else if (deleted)
        {
            scarabR.setConfirmMessage(l10n.get("GlobalIssueTypesDeleted"));
        }
        else
        {
            scarabR.setInfoMessage(l10n.get(NO_CHANGES_MADE));
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypes.java
public void doUndelete(RunData data, TemplateContext context)
        throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key;
        String id;
        IssueType issueType;
        boolean saved = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
                id = key.substring(7);
                issueType = IssueTypeManager.getInstance(new Integer(id));
                if (issueType != null)
                {
                    issueType.setDeleted(false);
                    issueType.save();
                    saved = true;
                }
            }
        }
        if (saved)
        {
            getScarabRequestTool(context)
                .setConfirmMessage(
                getLocalizationTool(context)
                .get("GlobalIssueTypesUnDeleted"));
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doAdduser(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        ScarabUser su = null;
        
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid())
        {
            Object user = data.getUser()
                .getTemp(ScarabConstants.SESSION_REGISTER);
            Group register = null;
            if (user != null && user instanceof ScarabUser)
            {
                register = intake.get("Register",
                                      ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                register = intake.get("Register",
                                      IntakeTool.DEFAULT_KEY, false);
            }
            
            su  = (ScarabUser) ScarabUserManager.getInstance();
            su.setUserName(register.get("UserName").toString());
            su.setFirstName(register.get("FirstName").toString());
            su.setLastName(register.get("LastName").toString());
            su.setEmail(register.get("Email").toString());
            su.setPassword(register.get("Password").toString().trim());

            try
            {
                if (ScarabUserImplPeer.checkExists(su))
                {
                    su = ScarabUserManager.reactivateUserIfDeleted(su);
                    if(su == null)
                    {
                        setTarget(data, template);
                        scarabR.setAlertMessage(L10NKeySet.UsernameExistsAlready);
                        data.getParameters().setString("errorLast","true");
                        data.getParameters().setString("state","showadduser");
                        return;
                    }
                }
                else
                {
                    su.createNewUser();
                }
            
                // if we got here, then all must be good...

                ScarabUserImpl.confirmUser(register.get("UserName").toString());
                // force the user to change their password the first time they login
                su.setPasswordExpire(Calendar.getInstance());
                Localizable msg = new L10NMessage(L10NKeySet.UserCreated,register.get("UserName").toString());
                scarabR.setConfirmMessage(msg);
                data.getParameters().setString("state","showadduser");
                data.getParameters().setString("lastAction","addeduser");
                
                setTarget(data, nextTemplate);
                return;
            }
            catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
        }
        else
        {
            data.getParameters().setString("state","showadduser");
            data.getParameters().setString("lastAction","");
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doEdituser(RunData data, TemplateContext context) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        ScarabUser su = null;
        
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid())
        {
            Object user = data.getUser()
                .getTemp(ScarabConstants.SESSION_REGISTER);
            Group register = null;
            if (user != null && user instanceof ScarabUser)
            {
                register = intake.get("Register",
                                          ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                register = intake.get("Register",
                                      IntakeTool.DEFAULT_KEY, false);
            }
            
            
            // if we got here, then all must be good...

            String username = data.getParameters().getString("username");
            su = ScarabUserManager.getInstance(username);
            try
            {
                if ((su != null) && (register != null))
                {
                    // update the first name, last name, email
                    // Turbine's security service does not allow
                    // changing the username, this is considered the
                    // defining info of a particular user.  SCB197 is
                    // a request to make this information modifiable.
                    su.setFirstName(register.get("FirstName").toString());
                    su.setLastName(register.get("LastName").toString());
                    su.setEmail(register.get("Email").toString());
                    su.setConfirmed(data.getParameters().getString("accountStatus"));
                    ScarabUserManager.putInstance((ScarabUserImpl)su);
                    TurbineSecurity.saveUser(su);
                    ScarabUserManager.getMethodResult().remove( 
                        ScarabUserManager.SCARAB_USER_MANAGER,
                        ScarabUserManager.GET_INSTANCE, username 
                    );
                    //
                    // Fix: SCB1065
                    // I think this fix really belongs in Turbine, but
                    // I'm not going to touch that code. So here's a 
                    // workaround.
                    //
                    User userInSession = data.getUser(); 
                    if (userInSession.getUserName().equals(username))
                    {
                        //
                        // The current user is trying to modify their
                        // own details. Update the user object in the
                        // session with the new values otherwise the
                        // old ones will be saved back to the database
                        // when the user logs out, or the session times
                        // out.
                        //
                        userInSession.setFirstName(su.getFirstName());
                        userInSession.setLastName(su.getLastName());
                        userInSession.setEmail(su.getEmail());
                        userInSession.setConfirmed(su.getConfirmed());
                    }


                    
                    String password;
                    String passwordConfirm;

                    String generatePassword = data.getParameters().getString("generate-password");
                    if(generatePassword!=null && generatePassword.equalsIgnoreCase("on"))
                    {
                        password = passwordConfirm = PasswordGenerator.generate();
                    }
                    else
                    {
                        password = register.get("NPassword").toString();
                        passwordConfirm = register.get("NPasswordConfirm").toString();                        
                    }
                        
                    if (!password.equals(""))
                    {
                        if (password.equals(passwordConfirm))
                        {
                            TurbineSecurity.forcePassword(su, password);
                            su.setPasswordExpire(Calendar.getInstance());
                            TurbineSecurity.saveUser(su);
                            ScarabUserManager.getMethodResult().remove(
                                ScarabUserManager.SCARAB_USER_MANAGER, 
                                ScarabUserManager.GET_INSTANCE, username 
                            );
                            User me = data.getUser();
                            try
                            {
                                data.setUser(su);
                                ForgotPassword.sendNotificationEmail(context, su, password);
                            }
                            catch(Exception e)
                            {
                                Localizable msg = new L10NMessage(L10NKeySet.ExceptionEmailFailure,e);
                                scarabR.setAlertMessage(msg);
                            }
                            data.setUser(me);
                        }
                        else
                        /* !password.equals(passwordConfirm) */
                        {
                            scarabR.setAlertMessage(L10NKeySet.PasswordsDoNotMatch);
                            return;
                        }
                    }
                    
                    
                    
                    Localizable msg = new L10NMessage(L10NKeySet.UserChangesSaved, username);
                    scarabR.setConfirmMessage(msg);
                    data.getParameters().setString("state", "showedituser");
                    data.getParameters().setString("lastAction", "editeduser");
                    
                    setTarget(data, nextTemplate);
                    return;
                }
                else
                {
                    Localizable msg = new L10NMessage(L10NKeySet.UserNotRetrieved, username);
                    scarabR.setAlertMessage(msg);
                    data.getParameters().setString("state", "showedituser");                    
                }
            }
            catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }   
        }
        else
        {
            data.getParameters().setString("state","showedituser");
            data.getParameters().setString("lastAction","");
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doDeleteuser(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        User user = null;
        String username = data.getParameters().getString("username");
        User userInSession = data.getUser(); 
        if (userInSession.getUserName().equals(username)){
            scarabR.setAlertMessage(L10NKeySet.UserCanNotDeleteSelf);
            return;
        }
        try
        {
            
            user = ScarabUserManager.getInstance(username);
            user.setConfirmed(ScarabUser.DELETED);
            TurbineSecurity.saveUser(user);
            ScarabUserManager.getMethodResult().remove(
                ScarabUserManager.SCARAB_USER_MANAGER,
                ScarabUserManager.GET_INSTANCE, username
            );
            List lista = (List)data.getUser().getTemp("userList");
            if (lista != null)
                lista.set(lista.indexOf(user), user);
            
            Localizable msg = new L10NMessage(L10NKeySet.UserDeleted, username);
            scarabR.setConfirmMessage(msg);
            data.getParameters().setString("state", "showedituser");
            data.getParameters().setString("lastAction", "editeduser");
            
            setTarget(data, nextTemplate);
            return;
            
           
        }
        catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }        
       
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doRoles(RunData data, TemplateContext context)
        throws Exception
    {
        String username = data.getParameters().getString("username");
        User user = ScarabUserManager.getInstance(username);
        
        AccessControlList acl = ((ScarabUser)user).getACL();
        
        // Grab all the Groups and Roles in the system.
        org.apache.fulcrum.security.entity.Group[] groups = TurbineSecurity.getAllGroups().getGroupsArray();
        Role[] roles = TurbineSecurity.getAllRoles().getRolesArray();
        
        for (int i = 0; i < groups.length; i++)
        {
            String groupName = groups[i].getName();
            
            for (int j = 0; j < roles.length; j++)
            {
                String roleName = roles[j].getName();
                String groupRole = groupName + roleName;
                
                String formGroupRole = data.getParameters().getString(groupRole);
                
                if (formGroupRole != null && !acl.hasRole(roles[j], groups[i]))
                {
                    TurbineSecurity.grant(user, groups[i], roles[j]);
                    // TODO: Needs to be refactored into the Users system?
                    ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.HAS_ROLE_IN_MODULE,
                    		(Serializable) roles[j], (Module)groups[i]);
                    
                }
                else if (formGroupRole == null && acl.hasRole(roles[j], groups[i]))
                {
                    TurbineSecurity.revoke(user, groups[i], roles[j]);
                    // TODO: Needs to be refactored into the Users system?
                    ScarabUserManager.getMethodResult().remove( user, ScarabUserManager.HAS_ROLE_IN_MODULE,
                    		(Serializable) roles[j], (Module)groups[i]);
                }
            }
        }
        // TODO: Needs to be refactored into the Users system?
        ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.GET_ACL);
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doGotoedituser(RunData data, TemplateContext context)
        throws Exception
    {
        String userName = data.getParameters().getString("username");
        if ((userName != null) && (userName.length() > 0))
        {
            data.getParameters().setString("state","showedituser");
            setTarget(data, "admin,EditUser.vm");
        }
        else
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.UserSelect);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doGotoeditroles(RunData data, TemplateContext context)
        throws Exception
    {
        String userName = data.getParameters().getString("username");
        if ((userName != null) && (userName.length() > 0))
        {
            setTarget(data, "admin,EditUserRoles.vm");
        }
        else
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.UserSelect);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doGotodeleteuser(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,DeleteUser.vm");
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doGotoadduser(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,AddUser.vm");
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doSearch(RunData data, TemplateContext context)
        throws Exception
    {
        String searchField = data.getParameters().getString("searchField");
        String searchCriteria = data.getParameters().getString("searchCriteria");
        String orderByField = data.getParameters().getString("orderByField");
        String ascOrDesc = data.getParameters().getString("ascOrDesc");
        String resultsPerPage= data.getParameters().getString("resultsPerPage");
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        scarabR.setGlobalUserSearchParam("searchField", searchField);
        scarabR.setGlobalUserSearchParam("searchCriteria", searchCriteria);
        scarabR.setGlobalUserSearchParam("orderByField", orderByField);
        scarabR.setGlobalUserSearchParam("ascOrDesc", ascOrDesc);
        scarabR.setGlobalUserSearchParam("resultsPerPage", resultsPerPage);
        
        setTarget(data, "admin,ManageUserSearch.vm");
    }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doSearch(data, context);
    }
            
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
public synchronized void doSave (RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        Module module = scarabR.getCurrentModule();
        List rmits = module.getRModuleIssueTypes();
        int navCount = 0;
        Group rmitGroup = null;

        if (areThereDupeSequences(rmits, intake, "RModuleIssueType", "Order", 0))
        {
            scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                                     l10n.get("IssueTypes").toLowerCase()));
            return;
        }

        if (intake.isAllValid())
        {
            for (int i=0;i < rmits.size(); i++)
            {
                RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
                rmitGroup = intake.get("RModuleIssueType", 
                                 rmit.getQueryKey(), false);
                Field display = rmitGroup.get("Display");

                if (display.toString().equals("true"))
                {
                    navCount++;
                }
                if (navCount > 5)
                {
                   scarabR.setAlertMessage(l10n.get("NavIssueTypeLimit"));
                   return;
                }
            }
            for (int i=0;i < rmits.size(); i++)
            {
                RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
                rmitGroup = intake.get("RModuleIssueType", 
                                 rmit.getQueryKey(), false);
                rmitGroup.setProperties(rmit);
                rmit.save();
                
                // TODO: document the reason for this
                String pageNum = data.getParameters().getString("pageNum","1");
                data.getParameters().add("pageNum", pageNum);
            }
            ScarabCache.clear();
        } 
    }
            
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
public void doSelectissuetype(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        Module module = scarabR.getCurrentModule();

        if (issueType.getIssueTypeId() == null)
        {
            scarabR.setAlertMessage(l10n.get("SelectIssueType"));
        }
        else if (module.getRModuleIssueType(issueType) != null)
        {
            scarabR.setAlertMessage(l10n.get("IssueTypeAlreadyAssociated"));
        }
        else
        {
            module.addIssueType(issueType);
            ScarabCache.clear();
            scarabR.setConfirmMessage(l10n.get("IssueTypeAddedToModule"));
            setTarget(data, "admin,ManageArtifactTypes.vm");            
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
public void doCreateartifacttype(RunData data, TemplateContext context)
        throws Exception
    {
        data.getParameters().remove("issueTypeId");
        setTarget(data, getOtherTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
public void doDeletemoduleissuetype (RunData data, 
                                          TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        ParameterParser params = data.getParameters();
        Module module = scarabR.getCurrentModule();
        Object[] keys = params.getKeys();
        String key;
        String issueTypeId;
        List rmits = module.getRModuleIssueTypes();

        boolean foundOne = false;
        boolean success = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
                if (rmits.size() < 1)
                {
                    scarabR.setAlertMessage(l10n.get("CannotZeroIssueType"));
                    break;
                }
                else
                {
                    issueTypeId = key.substring(7);
                    IssueType issueType = scarabR.getIssueType(issueTypeId);
                    RModuleIssueType rmit = module.getRModuleIssueType(issueType);
                    Group rmitGroup = getIntakeTool(context).get("RModuleIssueType", 
                                 rmit.getQueryKey(), false);
                    Field field = rmitGroup.get("DisplayName");
                    if (issueType != null)
                    {
                        foundOne = true;
                        if (issueType.getLocked())
                        {
                            //scarabR.setAlertMessage(l10n.get("LockedIssueType"));
                            field.setMessage("LockedIssueType");
                        }
                        else if (issueType.hasIssues(module))
                        {
                            scarabR.setAlertMessage(l10n.get("CannotDeleteIssueTypesWithIssues"));
                            field.setMessage("IssueTypeHasIssues");
                        }
                        else
                        {
                            try
                            {
                                // delete module-issue type mappings
                                rmit.delete(user);
                                success = true;
                                // FIXME! need proper cache invalidation
                                module.getNavIssueTypes().remove(issueType);
                            }
                            catch (Exception e)
                            {
                                scarabR.setAlertMessage(
                                    l10n.get("CannotDeleteIssueType"));
                                Log.get().warn(
                                    "Could not delete issue type", e);
                            }
                        }

                    }
                }
            }
         
         }
         if (success)
         { 
            String msg = l10n.get("SelectedIssueTypesRemovedFromModule");
            scarabR.setConfirmMessage(msg);
         }
         if (!foundOne)
         {
             String msg = l10n.get("SelectIssueTypeToDeleteFromModule");
             scarabR.setAlertMessage(msg);
         }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public boolean doSaveinfo(RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = getScarabRequestTool(context).getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return false;
        }
        Group group = intake.get("IssueType", issueType.getQueryKey());
        Field field = group.get("Name");
        String name = field.toString();
        Integer id = issueType.getIssueTypeId();

        if (intake.isAllValid()) 
        {
            if (id == null)
            {
                // Create new issue type
                // make sure name is unique
                if (IssueTypePeer.isUnique(name, null)) 
                {
                    group.setProperties(issueType);
                    issueType.setParentId(IssueTypePeer.getRootKey());
                    issueType.save();
                    
                    // Create default attribute groups
                    issueType.createDefaultGroups();

                    // Create template type.
                    IssueType template = new IssueType();
                    template.setName(issueType.getName() + " Template");
                    template.setParentId(issueType.getIssueTypeId());
                    template.save();
                }
                else 
                {
                    scarabR.setAlertMessage(l10n.get("IssueTypeNameExists"));
                }
            }
            else
            {
                // Edit existing issue type
                if (IssueTypePeer.isUnique(name, id)) 
                {
                    // Cannot delete an issue type that has issues 
                    Field deleted = group.get("Deleted");
                    if (deleted != null && deleted.toString().equals("true") 
                        && issueType.hasIssues())
                    {
                        scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
                        deleted.setMessage("IssueTypeHasIssues");
                        success = false;
                    }
                    else
                    {
                        group.setProperties(issueType);
                        issueType.save();
                        scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
                    }
                }
                else 
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.get("IssueTypeNameExists"));
                }
            }
        }
        else
        {
            scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
            success = false;
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public boolean doSavegroups (RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return false;
        }
        List attGroups = issueType.getAttributeGroups(null, false);
        int nbrAttGroups = attGroups.size();
        int dupeOrder = 2;

        // Manage attribute groups, only seeking sequence collisions
        // when there is more than one active group.
        if (issueType.getAttributeGroups(null, true).size() > 1)
        {
            dupeOrder = data.getParameters().getInt("dupe_order");

            // Check that duplicate check is not at the beginning.
            if (dupeOrder == 1)
            {
                scarabR.setAlertMessage(l10n.get("CannotPositionDuplicateCheckFirst"));
                return false;
            }

            // Check for duplicate sequence numbers
            if (areThereDupeSequences(attGroups, intake, "AttributeGroup",
                    "Order", dupeOrder))
            {
                scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                    l10n.get("AttributeGroups").toLowerCase()));
                return false;
            }
        }

        if (intake.isAllValid())
        {
            boolean areThereDedupeAttrs = false;
            // Set properties for attribute groups
            for (int i = nbrAttGroups - 1; i >= 0; i--)
            {
                AttributeGroup attGroup = (AttributeGroup)attGroups.get(i);
                Group agGroup = intake.get("AttributeGroup",
                                 attGroup.getQueryKey(), false);
                agGroup.setProperties(attGroup);

                // If an attribute group falls before the dedupe
                // screen, mark it as a dedupe group.  Even groups
                // which are currently empty of attributes should be
                // marked as such, as attributes may later be added to
                // them.
                areThereDedupeAttrs = attGroup.getOrder() < dupeOrder;
                attGroup.setDedupe(areThereDedupeAttrs);
                attGroup.save();
            }
            if (areThereDedupeAttrs)
            {
                Group itGroup = intake.get("IssueType",
                                        issueType.getQueryKey(), false);
                Field dedupe = itGroup.get("Dedupe");
                dedupe.setProperty(issueType);
            }
            issueType.save();
            ScarabCache.clear();
            scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
        }
        else
        {
            scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
            success = false;
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doCreatenewuserattribute(RunData data, 
                                          TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        Group attGroup = intake.get("Attribute", IntakeTool.DEFAULT_KEY);
        intake.remove(attGroup);
        scarabR.setAttribute(null);
        setTarget(data, getOtherTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public AttributeGroup doCreatenewgroup (RunData data, 
                                             TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return null;
        }
        scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
        return issueType.createNewGroup();
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doDeletegroup (RunData data, TemplateContext context)
        throws Exception
    {
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String groupId;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        List attributeGroups = issueType.getAttributeGroups(null, false);

        boolean atLeastOne = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("group_action"))
            {
                atLeastOne = true;
                groupId = key.substring(13);
                AttributeGroup ag = AttributeGroupManager
                    .getInstance(new NumberKey(groupId), false);
                if (Log.get().isDebugEnabled()) 
                {
                    Log.get().info("Deleting attribute group: " + groupId);
                }
                ag.delete();
                ScarabCache.clear();
            }
        }
        if (atLeastOne) 
        {
            scarabR.setConfirmMessage(l10n.get("SelectedGroupDeleted"));
            // TODO: this logic seems off by one to me (jmcnally), need
            // to document why this is not so, as it seems to work
            if (attributeGroups.size() -1 < 2)
            {
                // If there are fewer than 2 attribute groups,
                // Turn off deduping
                issueType.setDedupe(false);
                issueType.save();
            }
        }
        else 
        {
            scarabR.setAlertMessage(l10n.get("NoGroupSelected"));  
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doSelectuserattribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        String[] attributeIds = data.getParameters()
                                    .getStrings("attribute_ids");
 
        if (attributeIds == null || attributeIds.length <= 0)
        { 
            scarabR.setAlertMessage(l10n.get("SelectAttribute"));
            return;
        }
        else
        {        
            for (int i=0; i < attributeIds.length; i++)
            {
                Attribute attribute = 
                    scarabR.getAttribute(new Integer(attributeIds[i]));
                if (attribute != null)
                {
                    // add issuetype-attribute groupings
                    issueType.addRIssueTypeAttribute(attribute);
                }
                doCancel(data, context);
                ScarabCache.clear();
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doDeleteuserattribute(RunData data, TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ParameterParser params = data.getParameters();
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        Object[] keys = params.getKeys();
        String key;
        String attributeId;
        boolean atLeastOne = false;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("att_delete_"))
            {
               atLeastOne = true;
               attributeId = key.substring(11);
               Attribute attribute = AttributeManager
                   .getInstance(new NumberKey(attributeId), false);

               // Remove attribute - issue type mapping
               RIssueTypeAttribute ria = issueType
                   .getRIssueTypeAttribute(attribute);
               try
               {
                   ria.delete();
               }
               catch (Exception e)
               {
                   scarabR.setAlertMessage(l10n.get(NO_PERMISSION_MESSAGE));
               }

               scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
               ScarabCache.clear();
           }
        }        
        if (!atLeastOne)
        {
           scarabR.setAlertMessage(l10n.get("NoAttributesSelected"));
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public boolean doSaveuserattributes (RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType =  scarabR.getIssueType();
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return false;
        }
        if (intake.isAllValid())
        {
            List rias = issueType.getRIssueTypeAttributes(false,"user");
            if (areThereDupeSequences(rias, intake, "RIssueTypeAttribute",
                                          "Order", 0))
            {
                scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                    l10n.get("UserAttributes").toLowerCase()));
                return false;
            }
            for (int i=0; i < rias.size(); i++)
            {
                // Set properties for issue type-attribute mapping
                RIssueTypeAttribute ria = (RIssueTypeAttribute)rias.get(i);
                Group riaGroup = intake.get("RIssueTypeAttribute",
                                 ria.getQueryKey(), false);
                riaGroup.setProperties(ria);
                ria.save();
            }
            getScarabRequestTool(context)
                .setConfirmMessage(l10n.get(DEFAULT_MSG));
        }
        return true;
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = doSaveinfo(data, context) &&
                              doSavegroups(data, context) &&
                                  doSaveuserattributes(data, context);
        if (success)
        {
            doCancel(data, context);
        }
        //Reset confirm message in case some of the changes got saved
        else
        {
            getScarabRequestTool(context).setConfirmMessage(null);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
public void doGotoothertemplate(RunData data,
                                     TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType =  scarabR.getIssueType();
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        super.doGotoothertemplate(data,context);
    }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public synchronized void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Attribute attribute = scarabR.getAttribute();
        IssueType issueType =  scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(getLocalizationTool(context)
                                       .get("SystemSpecifiedIssueType"));
            return;
        }
        if (intake.isAllValid())
        {
            List rios = issueType.getRIssueTypeOptions(attribute, false);
            // Check for duplicate sequence numbers
            if (areThereDupeSequences(rios, intake,
                    "RIssueTypeOption","Order", 0))
            {
                scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                         l10n.get("AttributeOptions").toLowerCase()));
                return;
            }

            if (rios != null)
            {
                for (int i=rios.size()-1; i>=0; i--) 
                {
                    RIssueTypeOption rio = (RIssueTypeOption)rios.get(i);
                    Group rioGroup = intake.get("RIssueTypeOption",
                                     rio.getQueryKey(), false);
                    rioGroup.setProperties(rio);
                    rio.save();
                    ScarabCache.clear();
                    scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
                }
            }
        }
        if (attribute.isOptionAttribute())
        {
            List options = issueType.getRIssueTypeOptions(attribute, true);
            if (options == null || options.isEmpty())
            {
                RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
                if (ria.getRequired())
                {
                    ria.setRequired(false);        
                    ria.save();
                    scarabR.setAlertMessage(l10n.get("DeletedOptionsFromRequiredAttribute"));
                }
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public void doDeleteissuetypeoptions(RunData data,
                                          TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        IssueType issueType = scarabR.getIssueType();
        Attribute attribute = scarabR.getAttribute();

        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String optionId;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
               optionId = key.substring(7);
               AttributeOption option = AttributeOptionManager
                  .getInstance(new Integer(optionId));

               RIssueTypeOption rio = issueType.getRIssueTypeOption(option);
               List rios = issueType.getRIssueTypeOptions(attribute,
                                                          false);
               try
               {
                   rio.delete(user, scarabR.getCurrentModule());
                   rios.remove(rio);
               }
               catch (Exception e)
               {
                   scarabR.setAlertMessage(ScarabConstants.NO_PERMISSION_MESSAGE);
               }
               scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
            }
        }        
        if (attribute.isOptionAttribute())
        {
            List options = issueType.getRIssueTypeOptions(attribute, true);
            if (options == null || options.isEmpty())
            {
                RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
                if (ria.getRequired())
                {
                    ria.setRequired(false);        
                    ria.save();
                    scarabR.setAlertMessage(l10n.get("DeletedOptionsFromRequiredAttribute"));
                }
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public void doSelectissuetypeoption(RunData data, 
                                         TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        String[] optionIds = data.getParameters().getStrings("option_ids");
 
        if (optionIds == null || optionIds.length <= 0)
        {
            scarabR.setAlertMessage(l10n.get("SelectOption"));
            return;
        }
        else
        {        
            for (int i=0; i < optionIds.length; i++)
            { 
                AttributeOption option = null;
                try
                {
                    option = scarabR.getAttributeOption(new Integer(optionIds[i]));
                    issueType.addRIssueTypeOption(option);
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                }
            }
            doCancel(data, context);
            scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
        }
    }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public void doGotoothertemplate(RunData data,
                                     TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType =  scarabR.getIssueType();
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(l10n.get("SystemSpecifiedIssueType"));
            return;
        }
        super.doGotoothertemplate(data,context);
    }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
public void doDone( RunData data, TemplateContext context )
        throws Exception
    {
        doSave(data, context);
        if (getScarabRequestTool(context).getAlertMessage() == null)
        {
            doCancel( data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributes.java
public void doCreatenew(RunData data, TemplateContext context)
        throws Exception
    {
        String nextTemplate = data.getParameters().getString(
            ScarabConstants.OTHER_TEMPLATE, "admin, GlobalAttributeEdit.vm");
        setTarget(data, nextTemplate);

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        scarabR.setAttribute(AttributeManager.getInstance());
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributes.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        List userAttrs = AttributePeer.getAttributes("user");
        for (int i=0; i<userAttrs.size(); i++)
        {
            Attribute attr = (Attribute)userAttrs.get(i);
            Group attrGroup = intake.get("Attribute", attr.getQueryKey());
            if (attrGroup != null)
            {
                attrGroup.setProperties(attr);
                attr.save();
            }
        }
        ScarabCache.clear();
        getScarabRequestTool(context).setConfirmMessage(getLocalizationTool(context).get(DEFAULT_MSG));
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributes.java
public synchronized void doCopy(RunData data, TemplateContext context)
        throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key = null;
        String id = null;
        Attribute attribute = null;
        boolean didCopy = false;
        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("action_"))
            {
               id = key.substring(7);
               attribute = AttributeManager.getInstance(new Integer(id));
               Attribute newAttribute = attribute
                  .copyAttribute((ScarabUser)data.getUser());
               newAttribute.save();
               didCopy = true;
            }
        }
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        if (didCopy)
        {
            scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
        }
        else
        {
            scarabR.setInfoMessage(l10n.get(NO_CHANGES_MADE));
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doGotoaddrole(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,AddRole.vm");
    }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doGotoeditrole(RunData data, TemplateContext context)
        throws Exception
    {
        checkParamValidity(data, context, "admin,EditRole.vm");
    }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doGotodeleterole(RunData data, TemplateContext context)
        throws Exception
    {
        checkParamValidity(data, context, "admin,DeleteRole.vm");
    }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doAddrole(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        if (intake.isAllValid())
        {
            Object user = data.getUser().getTemp(ScarabConstants.SESSION_REGISTER);
            
            Group editRole = null;
            if (user != null && user instanceof ScarabUser)
            {
                editRole = intake.get("EditRole", ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                editRole = intake.get("EditRole", IntakeTool.DEFAULT_KEY, false);
            }
            String name = editRole.get("RoleName").toString();
            
            try
            {        
                Role role = TurbineSecurity.getNewRole(null);
                role.setName(name);
                
                TurbineSecurity.addRole(role);

                String msg = l10n.format("RoleCreated", name);
                getScarabRequestTool(context).setConfirmMessage(msg);

                data.getParameters().setString("name", name);
                doGotoeditrole(data, context);
            }
            catch (EntityExistsException eee)
            {
                String msg = l10n.format("RoleExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doEditrole(RunData data, TemplateContext context)
        throws Exception
    {
        /*
         * Grab the role we are trying to update.
         */
        String name = data.getParameters().getString("name");
        checkParamValidity(data, context, null);
        Role role = TurbineSecurity.getRole(name);
        
        /*
         * Grab the permissions for the role we are
         * dealing with.
         */
        PermissionSet rolePermissions = role.getPermissions();
        
        /*
         * Grab all the permissions.
         */
        Permission[] permissions = TurbineSecurity.getAllPermissions()
            .getPermissionsArray();
        
        String roleName = role.getName();
        
        for (int i = 0; i < permissions.length; i++)
        {
            String permissionName = permissions[i].getName();
            String rolePermission = roleName + permissionName;
            
            String formRolePermission = data.getParameters().getString(rolePermission);
            Permission permission = TurbineSecurity.getPermission(permissionName);
            
            
            if (formRolePermission != null && !rolePermissions.contains(permission))
            {
                /*
                 * Checkbox has been checked AND the role doesn't already
                 * contain this permission. So assign the permission to
                 * the role.
                 */
                
                role.grant(permission);
            }
            else if (formRolePermission == null && rolePermissions.contains(permission))
            {
                /*
                 * Checkbox has not been checked AND the role
                 * contains this permission. So remove this
                 * permission from the role.
                 */
                role.revoke(permission);
            }
        }
        
        ScarabUserManager.getMethodResult().clear();
    }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doDeleterole(RunData data, TemplateContext context)
        throws Exception
    {
        /*
         * Grab the role we are trying to delete.
         */
        String name = data.getParameters().getString("name");
        Role role = TurbineSecurity.getRole(name);
        TurbineSecurity.removeRole(role);
        
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        String msg = l10n.format("RoleDeleted", name);
        getScarabRequestTool(context).setConfirmMessage(msg);
        setTarget(data, data.getParameters()
                      .getString(ScarabConstants.NEXT_TEMPLATE, "admin,ManageRoles.vm"));
    }
            
// in java/org/tigris/scarab/actions/admin/ManageRoles.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doCancel(data,context);
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public boolean doSaveattributedata(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        boolean success = true;
        boolean confirmDelete = false;

        if (intake.isAllValid())
        {
            Attribute attr = scarabR.getAttribute();

            Group attrGroup = null;
            boolean isDupe = false;
            Field attributeName = null;
            Field description = null;
            if (attr.getAttributeId() == null)
            {
                // new attribute
                attrGroup = intake.get("Attribute", IntakeTool.DEFAULT_KEY);
                attr.setCreatedBy(((ScarabUser)data.getUser()).getUserId());
                attr.setCreatedDate(new Date());
            }
            else
            {
                attrGroup = intake.get("Attribute", attr.getQueryKey());
            }
            attributeName = attrGroup.get("Name");
            description = attrGroup.get("Description");
            isDupe = Attribute.checkForDuplicate(attributeName.toString().trim(), attr);

            // Check for blank attribute names.
            if (attributeName.toString().trim().length() == 0)
            {
                attributeName.setMessage("intake_AttributeNameNotAllowedEmpty");
                scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
                success = false;
            }
            if (description.toString().trim().length() == 0)
            {
                description.setMessage("intake_AttributeDescriptionNotAllowedEmpty");
                scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
                success = false;
            }
            // Check for duplicate attribute names.
            else if (isDupe)
            {
                scarabR.setAlertMessage(
                    l10n.get("CannotCreateDuplicateAttribute"));
                success = false;
            }
            else
            {
                // if deleting attribute, and attribute is associated
                // With modules or issue types, give confirmation.
                if (!attr.getDeleted() && 
                    attrGroup.get("Deleted").toString().equals("true") &&
                    (attr.hasModuleMappings() ||
                     attr.hasGlobalIssueTypeMappings()))
                {
                    context.put("deleting", "deleting");
                    confirmDelete=true;
                    success = false;
                }
                for (int i = 0; i < attrGroup.getFieldNames().length; i++)
                {
                    String fieldName = attrGroup.getFieldNames()[i];
                    if (!fieldName.equals("Deleted") || !confirmDelete)
                    {
                        attrGroup.get(fieldName).setProperty(attr);
                    }
                }
                attr.save();
                mapAttribute(data,context);
                if (success)
                {
                    scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
                    AttributeManager.clear();
                }
            }
        }
        else
        {
          success = false;
          scarabR.setAlertMessage(l10n.get(ERROR_MESSAGE));
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public void doDeleteattribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Attribute attr = scarabR.getAttribute();
        if (attr.isSystemDefined())
        {
            scarabR.setAlertMessage(getLocalizationTool(context).get
                                  ("CannotDeleteSystemSpecifiedAttribute"));
            return;
        }
        if (attr.getAttributeId() != null)
        {
            attr.deleteModuleMappings(); 
            attr.deleteIssueTypeMappings();
            attr.setDeleted(true);
            attr.save();
            scarabR.setConfirmMessage(getLocalizationTool(context).get(DEFAULT_MSG));  
            setTarget(data, getCancelTemplate(data));
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public synchronized boolean 
        doSaveoptions(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = (IntakeTool)context
           .get(ScarabConstants.INTAKE_TOOL);
        ScarabRequestTool scarabR = (ScarabRequestTool)context
           .get(ScarabConstants.SCARAB_REQUEST_TOOL);
        ScarabLocalizationTool l10n = getLocalizationTool(context);

        if (intake.isAllValid()) 
        {
            // get the Attribute that we are working on
            Attribute attribute = scarabR.getAttribute();
            if (log().isDebugEnabled()) 
            {
                log().debug("doSaveoptions for attribute id=" + 
                            attribute.getAttributeId());
            }
            Group attGroup = intake.get("Attribute", attribute.getQueryKey());
            String attributeTypeId = attGroup.get("TypeId").toString();
            AttributeType attributeType = AttributeTypeManager
                .getInstance(new NumberKey(attributeTypeId), false);

            if (attributeType.getAttributeClass().getName()
                                                 .equals("select-one"))
            {
                if (log().isDebugEnabled()) 
                {
                    log().debug("attribute id=" + attribute.getAttributeId() + 
                                " is an option attribute");
                }
                boolean somethingSaved = false;
                // get the list of ParentChildAttributeOptions's 
                // used to display the page
                List pcaoList = attribute.getParentChildAttributeOptions();
                // Check for duplicate sequence numbers
                if (areThereDupeSequences(pcaoList, intake,
                        "ParentChildAttributeOption","PreferredOrder", 0))
                {
                    scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                         l10n.get("AttributeOptions").toLowerCase()));
                    return false;
                }
                for (int i=pcaoList.size()-1; i>=0; i--) 
                {
                    ParentChildAttributeOption pcao = 
                        (ParentChildAttributeOption)pcaoList.get(i);

                    if (pcao.getChildOption().isSystemDefined()) 
                    {
                        if (Log.get().isDebugEnabled()) 
                        {
                            Log.get().debug("PCAO(" + pcao + 
                                ") is used by a system defined issue type");
                        }                        
                    }
                    else 
                    {
                    Group pcaoGroup = intake.get("ParentChildAttributeOption", 
                                                  pcao.getQueryKey());

                    // there could be errors here so catch and re-display
                    // the same screen again.
                    Integer currentParentId = null;
                    try
                    {
                        // store the currentParentId
                        currentParentId = pcao.getParentId();
                        // map the form data onto the objects
                        pcaoGroup.setProperties(pcao);
 
                        // If deleting, delete mappings with module 
                        if (pcao.getDeleted())
                        {
                            AttributeOption option = AttributeOptionPeer
                                .retrieveByPK(pcao.getOptionId());
                            if (log().isDebugEnabled()) 
                            {
                                log().debug("deleting mappings for option id=" + 
                                            option.getOptionId());
                            }
                            option.deleteModuleMappings();
                            option.deleteIssueTypeMappings();
                        }

                        List ancestors = null;
                        try
                        {
                            ancestors= pcao.getAncestors();
                        }
                        catch (Exception e)
                        {
                            scarabR.setAlertMessage(
                               l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
                        if (ancestors.contains(pcao.getOptionId()))
                        {
                            scarabR.setAlertMessage(
                                l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
                    
                        // save the PCAO now..
                        pcao.save();

                        // if we are changing the parent id's, then we want
                        // to remove the old one after the new one is created
                        if (!pcao.getParentId().equals(currentParentId))
                        {
                            if (log().isDebugEnabled()) 
                            {
                                log().debug("removing parent relationship for option id=" + 
                                            pcao.getOptionId() + ", old parent id="
                                            + currentParentId);
                            }
                            ROptionOption.doRemove(currentParentId, 
                                                   pcao.getOptionId());
                        }

                       // also remove the group because we are re-displaying
                       // the form data and we want it fresh
                       intake.remove(pcaoGroup);
                       if (log().isDebugEnabled()) 
                       {
                           log().debug("Saved pcao for attribute id=" + 
                                       pcao.getAttributeId() + " and option id="
                                       + pcao.getOptionId());
                       }
                       somethingSaved = true;
                    }
                    catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
                }
                }
                // all existing attribute options are checked
                
                if (somethingSaved)
                {
                    scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
                    AttributeManager.clear();
                }

                // handle adding the new line.
                ParentChildAttributeOption newPCAO = 
                    ParentChildAttributeOption.getInstance();
                Group newPCAOGroup = intake.get("ParentChildAttributeOption", 
                                                newPCAO.getQueryKey());
                if (newPCAOGroup != null) 
                {
                    log().debug("checking for a new pcao");
                    try
                    {
                        // assign the form data to the object
                        newPCAOGroup.setProperties(newPCAO);
                        // only add a new entry if there is a name defined
                        if (newPCAO.getName() != null && newPCAO.getName().length() > 0)
                        {
                            // save the new PCAO
                            newPCAO.setAttributeId(attribute.getAttributeId());
                            try
                            {
                                newPCAO.save();
                                if (log().isDebugEnabled()) 
                                {
                                    log().debug("Saved NEW pcao for attribute id="
                                                + newPCAO.getAttributeId() + " and option id="
                                                + newPCAO.getOptionId());
                                }
                                pcaoList.add(newPCAO);
                                IssueType issueType = null;
                                AttributeOption option = null;

                                // If user came from editing a module,
                                // Add new option to module.
                                String cancelTemplate = getCancelTemplate(data);
                                if (cancelTemplate != null
                                    && (cancelTemplate.equals("admin,AttributeOptionSelect.vm")
                                        || cancelTemplate.equals("admin,GlobalAttributeOptionSelect.vm")))
                                {
                                    issueType = scarabR.getIssueType();
                                    option = scarabR.getAttributeOption(newPCAO.getOptionId());
                                    if (log().isDebugEnabled()) 
                                    {
                                        log().debug("cancelTemplate=" + 
                                                    cancelTemplate + 
                                                    " issuetype id=" + 
                                                    issueType.getIssueTypeId() + 
                                                    " and option id=" + 
                                                    option.getOptionId());
                                    }
                                }
                                // add new option to current module
                                if (cancelTemplate.equals("admin,AttributeOptionSelect.vm"))
                                {
                                    scarabR.getCurrentModule()
                                       .addAttributeOption(issueType, option);
                                    data.getParameters().setString(
                                         ScarabConstants.CANCEL_TEMPLATE, 
                                         "admin,ModuleAttributeEdit.vm");
                                    if (log().isDebugEnabled()) 
                                    {
                                        log().debug("Adding mapping to module id" 
                                                    + scarabR.getCurrentModule()
                                                    .getModuleId());
                                    }
                                }
                                // add new option to current issue type
                                else if (cancelTemplate.equals("admin,GlobalAttributeOptionSelect.vm"))
                                {
                                    issueType.addRIssueTypeOption(option);
                                    data.getParameters().setString(
                                         ScarabConstants.CANCEL_TEMPLATE, 
                                         "admin,IssueTypeAttributeEdit.vm");
                                    log().debug("Adding mapping to issuetype");
                                }
                                scarabR.setConfirmMessage(
                                    l10n.get("AttributeOptionAdded") + 
                                    l10n.get(DEFAULT_MSG));
                            }
                            catch (Exception e)
                            {
                                log().error("Error adding attribute option:", e);
                                scarabR.setAlertMessage("Error adding attribute option:" + l10n.getMessage(e));
                            }
                        }
                    }
                    catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }

                    // now remove the group to set the page stuff to null
                    intake.remove(newPCAOGroup);
                    attribute.buildOptionsMap();
                    ScarabCache.clear();
                }
            }
        }
        return true;
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public void doDone(RunData data, TemplateContext context)
        throws Exception
    {
        log().debug("called doDone");
        boolean success = doSaveattributedata(data, context);
        if (getScarabRequestTool(context).getAttribute().isOptionAttribute())
        {
            success = doSaveoptions(data, context);
            updatetransitiondata(data, context);            
        }
        if (success)
        {
            //if "deleting" is set, do not call 'doCancel' since the control
            //should go to 'confirm delete' page.
            if(!"deleting".equals(context.get("deleting")))
            {
                log().debug("calling doCancel");
                doCancel(data, context);
            }
        }
        //Reset confirm message in case some of the changes got saved
        else
        {
            getScarabRequestTool(context).setConfirmMessage(null);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
private void mapAttribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String lastTemplate = getCancelTemplate(data);
        Attribute attribute = scarabR.getAttribute();

        if (log().isDebugEnabled())
        {
            log().debug("called mapAttribute; lastTemplate=" + lastTemplate +
                        " and attribute id=" + attribute.getAttributeId());
        }
        if (lastTemplate != null && attribute.getAttributeId() != null)
        {
            // Add attribute to group
            if (lastTemplate.equals("admin,AttributeGroupEdit.vm") ||
                lastTemplate.equals("admin,GlobalAttributeGroupEdit.vm"))
            {
                // Add attribute to group
                String groupId = data.getParameters().getString("groupId");
                if (groupId != null)
                {
                    if (log().isDebugEnabled())
                    {
                        log().debug("Adding attribute to group id=" + groupId);
                    }
                    AttributeGroup attributeGroup = scarabR.getAttributeGroup(groupId);
                    if(!attributeGroup.hasAttribute(attribute))
                    {
                        scarabR.getAttributeGroup(groupId).addAttribute(attribute);
                        scarabR.setConfirmMessage(l10n.get("AttributeAdded"));
                    }
                }
            }
            else if (lastTemplate.equals("admin,ArtifactTypeEdit.vm"))
            {
            Module currentModule = scarabR.getCurrentModule();
                IssueType issueType = scarabR.getIssueType();
                if (log().isDebugEnabled())
                {
                    log().debug("Adding attribute to module id=" +
                                currentModule.getModuleId());
                }
                // Add user attribute to module
                if (!attribute.hasMapping(currentModule, issueType))
                {
                      currentModule.addRModuleAttribute(issueType,attribute);
                      scarabR.setConfirmMessage(l10n.get("AttributeAdded"));
                }

            }
            else if (lastTemplate.equals("admin,GlobalArtifactTypeEdit.vm"))
            {
                IssueType issueType = scarabR.getIssueType();
                if (log().isDebugEnabled())
                {
                    log().debug("Assuming user attribute and adding to "
                                + "issuetype id "
                                + issueType.getIssueTypeId());
                }
                // Add user attribute to issue type
                if (!attribute.hasGlobalMapping(issueType))
                {
                   issueType.addRIssueTypeAttribute(attribute);
                   scarabR.setConfirmMessage(l10n.get("AttributeAdded"));
                }
            }
            ScarabCache.clear();
        }

    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public void doCancel(RunData data, TemplateContext context)
        throws Exception
    {
        String lastTemplate = getCancelTemplate(data);
        if (lastTemplate != null)
        {
            setTarget(data, lastTemplate);
        }
        else
        {
            super.doCancel(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public boolean doSavetransitiondata(RunData data, TemplateContext context)
            throws Exception
    {
        boolean bRdo = false;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Attribute attr = scarabR.getAttribute();
        Integer attributeId = attr.getAttributeId();
        if (!data.getParameters().getString("trans_new_RoleId").equals("choose") &&
                !data.getParameters().getString("trans_new_FromId").equals("choose") &&
                !data.getParameters().getString("trans_new_ToId").equals("choose"))
        {
            Integer roleId = data.getParameters().getInteger("trans_new_RoleId");
            Integer fromId = data.getParameters().getInteger("trans_new_FromId");
            Integer toId = data.getParameters().getInteger("trans_new_ToId");

            if (roleId.intValue() == -1)
                roleId = null;
            if (fromId.intValue() == -1)
                fromId = null;
            if (toId.intValue() == -1)
                toId = null;
            try
            {
                Transition transition = new Transition();
                transition.setRoleId(roleId);
                transition.setFromOptionId(fromId);
                transition.setToOptionId(toId);
                transition.setAttributeId(attributeId);
                attr.addTransition(transition);
                attr.save();
                transition.save();
                TransitionManager.getMethodResult().remove(attr, TransitionManager.GET_ALL_TRANSITIONS);
                bRdo = true;
            }
            catch (TorqueException te)
            {
                this.log().error("doSavetransitiondata(): " + te);
            }            
        }
        updatetransitiondata(data, context);
        
        return bRdo;
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
public boolean doDeletetransitiondata(RunData data, TemplateContext context)
            throws Exception
    {
        boolean bRdo = false;
        boolean bChanges = false;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Attribute attr = scarabR.getAttribute();
        List transitions = attr.getTransitions();
        Iterator iter = transitions.iterator();

        // Will store the transitions to delete in order to avoid the
        // ConcurrentModificationException??
        List toDelete = new ArrayList();
        try
        {
            while (iter.hasNext())
            {
                Transition trans = (Transition) iter.next();
                boolean bDelete = data.getParameters().getBoolean(
                        "trans_delete_" + trans.getTransitionId());
                if (bDelete)
                {
                    bChanges = true;
                    toDelete.add(trans);
                    AttributeManager.clear();
                }
            }
            iter = toDelete.iterator();
            while (iter.hasNext())
            {
                Transition trans = (Transition) iter.next();
                transitions.remove(trans);
                TransitionPeer.doDelete(trans);
            }
            if (toDelete.size() > 0)
            {
                TransitionManager.getMethodResult().remove(attr, TransitionManager.GET_ALL_TRANSITIONS);
            }
            bRdo = true;
        }
        catch (TorqueException te)
        {
            this.log().error("doDeleteTransition(): " + te);
        }
        scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));
        return bRdo;
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
private void updatetransitiondata(RunData data, TemplateContext context) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Attribute attr = scarabR.getAttribute();
        List transitions = attr.getTransitions();
        boolean bChanges = false;
        for (Iterator iter = transitions.iterator(); iter.hasNext(); )
        {
            // Update the "disabled if blocked" value
            Transition trans = (Transition)iter.next();
            boolean value = data.getParameters().getBoolean("trans_disabled_value_" + trans.getTransitionId());
            boolean newValue = data.getParameters().getBoolean("trans_disabled_new_" + trans.getTransitionId());
            if (value != newValue)
            {
                trans.setDisabledIfBlocked(newValue);
                trans.save();
                bChanges = true;
            }
        }
        if (bChanges)
        {
            TransitionManager.getMethodResult().remove(attr, TransitionManager.GET_ALL_TRANSITIONS);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
public synchronized void doSave (RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module module = scarabR.getCurrentModule();
        IssueType issueType = scarabR.getIssueType();

        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(l10n.get("LockedIssueType"));
            return;
        }
        Attribute attribute = scarabR.getAttribute();
        RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
        if (ria != null && ria.getLocked())
        {
            scarabR.setAlertMessage(l10n.format("LockedAttribute", attribute.getName()));
            return;
        }

        
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid())
        {
            List rmos = module.getRModuleOptions(attribute, issueType, false);
            // Check for duplicate sequence numbers
            if (areThereDupeSequences(rmos, intake, "RModuleOption", "Order", 0))

            {
                scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                         l10n.get("AttributeOptions").toLowerCase()));
                return;
            }
            if (rmos != null)
            {
                for (int i=rmos.size()-1; i>=0; i--) 
                {
                    RModuleOption rmo = (RModuleOption)rmos.get(i);
                    Group rmoGroup = intake.get("RModuleOption",
                                     rmo.getQueryKey(), false);
                    // if option gets set to inactive, delete dependencies
                    if (rmoGroup != null)
                    {
                        String newActive = rmoGroup.get("Active").toString();
                        String oldActive = String.valueOf(rmo.getActive());
                        if (newActive.equals("false") && oldActive.equals("true"))
                        {
                            WorkflowFactory.getInstance().deleteWorkflowsForOption(
                                                          rmo.getAttributeOption(),
                                                          module, issueType);
                        }
                        rmoGroup.setProperties(rmo);
                        rmo.save();
                    }
                    ScarabCache.clear();
                    scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
                }
            }
        }
        if (attribute.isOptionAttribute())
        {
            List options = module.getRModuleOptions(attribute, issueType, true);
            if (options == null || options.isEmpty())
            {
                RModuleAttribute rma = module.getRModuleAttribute(attribute, issueType);
                if (rma.getRequired())
                {
                    rma.setRequired(false);        
                    rma.save();
                    scarabR.setAlertMessage(l10n.get("DeletedOptionsFromRequiredAttribute"));
                }
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
public void doDeleteattributeoptions(RunData data,
                                          TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(l10n.get("LockedIssueType"));
            return;
        }
        Attribute attribute = scarabR.getAttribute();
        RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
        if (ria != null && ria.getLocked())
        {
            scarabR.setAlertMessage(l10n.format("LockedAttribute", attribute.getName()));
            return;
        }

        Module module = scarabR.getCurrentModule();
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String optionId;

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("delete_"))
            {
               optionId = key.substring(7);
               AttributeOption option = AttributeOptionManager
                  .getInstance(new Integer(optionId));

               RModuleOption rmo = module.getRModuleOption(option, issueType);
               rmo.delete();

               // Remove option - module mapping from template type
               RModuleOption rmo2 = module.getRModuleOption(option, 
                   scarabR.getIssueType(issueType.getTemplateId().toString()));
               rmo2.delete();
               scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
               ScarabCache.clear();
               getIntakeTool(context).removeAll();
               data.getParameters().add("att_0id", option.getAttribute().getAttributeId().toString());
            }
        }        
        if (attribute.isOptionAttribute())
        {
            List options = module.getRModuleOptions(attribute, issueType, true);
            if (options == null || options.isEmpty())
            {
                RModuleAttribute rma = module.getRModuleAttribute(attribute, issueType);
                if (rma.getRequired())
                {
                    rma.setRequired(false);        
                    rma.save();
                    scarabR.setAlertMessage(l10n.get("DeletedOptionsFromRequiredAttribute"));
                }
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
public void doSelectattributeoption(RunData data, 
                                         TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.getLocked())
        {
            scarabR.setAlertMessage(l10n.get("LockedIssueType"));
            return;
        }
        Attribute attribute = scarabR.getAttribute();
        RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
        if (ria != null && ria.getLocked())
        {
            scarabR.setAlertMessage(l10n.format("LockedAttribute", attribute.getName()));
            return;
        }
        Module module = scarabR.getCurrentModule();

        String[] optionIds = data.getParameters().getStrings("option_ids");
 
        if (optionIds == null || optionIds.length <= 0)
        { 
            scarabR.setAlertMessage(l10n.get("SelectOption"));
            return;
        }
        else
        {        
            for (int i=0; i < optionIds.length; i++)
            {
                AttributeOption option = null;
                try
                {
                    option = scarabR.getAttributeOption(new Integer(optionIds[i]));
                    module.addAttributeOption(issueType, option);
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                }
            }
            ScarabCache.clear();
            scarabR.setConfirmMessage(l10n.get(DEFAULT_MSG));  
            doCancel(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
public void doDone( RunData data, TemplateContext context )
        throws Exception
    {
        doSave(data, context);
        if (getScarabRequestTool(context).getAlertMessage() == null)
        {
            doCancel( data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public boolean doSaveinfo (RunData data, TemplateContext context)
        throws Exception
    { 
        boolean success = true;
        // Set properties for group info
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }
        String groupId = data.getParameters().getString("groupId");
        AttributeGroup ag = AttributeGroupManager
                            .getInstance(new NumberKey(groupId), false);
        Group agGroup = intake.get("AttributeGroup", 
                                    ag.getQueryKey(), false);
        if (!ag.isGlobal() && scarabR.getIssueType().getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return false;
        }
        if (intake.isAllValid())
        {
            agGroup.setProperties(ag);
            ag.save();
            scarabR.setConfirmMessage(DEFAULT_MSG);
        }
        else
        {
            success = false;
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public boolean doSaveattributes (RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IntakeTool intake = getIntakeTool(context);
        IssueType issueType = scarabR.getIssueType();
        Module module = scarabR.getCurrentModule();

        // Check if issue type is system-defined, hence unmodifyable
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }

        String groupId = data.getParameters().getString("groupId");
        AttributeGroup attributeGroup = AttributeGroupManager
                            .getInstance(new NumberKey(groupId), false);
        
        LocalizationKey l10nKey = DEFAULT_MSG;

        // Check if issue type is locked
        if (!attributeGroup.isGlobal() && issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return false;
        }

        // Check for duplicate sequence numbers
        if (areThereDupeSequences(attributeGroup.getRAttributeAttributeGroups(), intake,
                "RAttributeAttributeGroup", "Order", 0))
        {
            scarabR.setAlertMessage(
                l10n.format("DuplicateSequenceNumbersFound",
                l10n.get(L10NKeySet.Attributes).toLowerCase()));
            return false;
        }

        List rmas = attributeGroup.getRModuleAttributes();
        ArrayList lockedAttrs = new ArrayList();

        if (intake.isAllValid())
        {
            // First iterate thru and check for required attributes
            // That have no active options
            Iterator i = rmas.iterator();
            while (i.hasNext()) 
            {
                RModuleAttribute rma = (RModuleAttribute)i.next();
                Group rmaGroup = intake.get("RModuleAttribute", 
                                 rma.getQueryKey(), false);
                Attribute attr = rma.getAttribute();
                if (attr.isOptionAttribute() && rmaGroup.get("Required").toString().equals("true"))
                {
                    List options = module.getRModuleOptions(rma.getAttribute(), issueType, true);
                    if (options == null || options.isEmpty())
                    {
                        scarabR.setAlertMessage(L10NKeySet.CannotRequireAttributeWithNoOptions);
                        success = false;
                    }
                }
            }
            if (success)
            {
                

                // Check whether a module specific statusAttribute was selected
                // and store it in the GLOBAL_PARAMETER table
                String key = "status_attribute_"+issueType.getIssueTypeId();
                String statusAttributeKey = data.getParameters()
                   .getString(key);
                if ( statusAttributeKey != null ) 
                {
                    String attributeId = GlobalParameterManager.getString(key,module);
                    if(attributeId == null || !attributeId.equals(statusAttributeKey))
                    {
                        GlobalParameterManager.setString(key, module, statusAttributeKey);
                    }
                }
                
                
                i = rmas.iterator();
                while (i.hasNext()) 
                {
                    boolean locked = false;
                    // Set properties for module-attribute mapping
                    RModuleAttribute rma = (RModuleAttribute)i.next();
                    Group rmaGroup = intake.get("RModuleAttribute", 
                                     rma.getQueryKey(), false);
                    Attribute attr = rma.getAttribute();

                    // Test to see if attribute is locked
                    RModuleAttribute rmaTest = rma.copy();
                    rmaTest.setModified(false);
                    rmaGroup.setProperties(rmaTest);
                    if (rmaTest.isModified())
                    {
                        RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        if (ria != null &&  ria.getLocked())
                        {
                             lockedAttrs.add(attr);
                             locked = true;
                        }
                    }

                    if (!locked)
                    {
                        // if attribute gets set to inactive, delete dependencies
                        String newActive = rmaGroup.get("Active").toString();
                        String oldActive = String.valueOf(rma.getActive());
                        if (newActive.equals("false") && oldActive.equals("true"))
                        {
                            WorkflowFactory.getInstance()
                                .deleteWorkflowsForAttribute(attr, module, 
                                                             issueType);
                        }
                        rmaGroup.setProperties(rma);
                        String defaultTextKey = data.getParameters()
                          .getString("default_text");
                        if (defaultTextKey != null && 
                             defaultTextKey.equals(rma.getAttributeId().toString())) 
                        {
                            if (!rma.getRequired())
                            {
                                l10nKey = L10NKeySet.ChangesSavedButDefaultTextAttributeRequired;
                                intake.remove(rmaGroup);
                            }
                            rma.setIsDefaultText(true);
                            rma.setRequired(true);
                        }
                        
                        try
                        {
                            rma.save();
                            // Set properties for attribute-attribute group mapping
                            RAttributeAttributeGroup raag = 
                                attributeGroup.getRAttributeAttributeGroup(attr);
                            Group raagGroup = intake.get("RAttributeAttributeGroup", 
                                         raag.getQueryKey(), false);
                            raagGroup.setProperties(raag);
                            raag.save();
                            scarabR.setConfirmMessage(l10nKey);
                        }
                        catch (ScarabLocalizedTorqueException slte) 
                        {
                            String msg = slte.getMessage(l10n);
                            scarabR.setAlertMessage(msg);
                        }
                        catch (TorqueException te) 
                        {
                            String msg = te.getMessage();
                            scarabR.setAlertMessage(msg);
                        }
                    }

                    // If they attempted to modify locked attributes, give message.
                    if (lockedAttrs.size() > 0)
                    {
                        setLockedMessage(lockedAttrs, context);
                    }
                }
            }
        } 
        else
        {
            success = false;
            scarabR.setAlertMessage(L10NKeySet.MoreInformationWasRequired);
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public boolean doSaveglobal (RunData data, TemplateContext context)
        throws Exception
    {
        boolean success = true;
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String groupId = data.getParameters().getString("groupId");
        AttributeGroup ag = AttributeGroupManager
                            .getInstance(new NumberKey(groupId), false);
        IssueType issueType = scarabR.getIssueType();

        // Check if issue type is system defined, hence unmodifyable
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return false;
        }
        if (issueType.getIssueTypeId() == null)
        {
            scarabR.setAlertMessage(L10NKeySet.IssueTypeNotFound);
            return false;
        }


        // Check for duplicate sequence numbers
        if (areThereDupeSequences(ag.getRAttributeAttributeGroups(), intake,
                                       "RAttributeAttributeGroup", "Order",0))
        {
            scarabR.setAlertMessage(l10n.format("DuplicateSequenceNumbersFound",
                l10n.get("Attributes").toLowerCase()));
            return false;
        }
        String l10nMsg = l10n.get(DEFAULT_MSG);

        if (intake.isAllValid())
        {
            List rias = ag.getRIssueTypeAttributes();

            // first check if there are required attributes
            // Without active options
            Iterator i = rias.iterator();
            while (i.hasNext()) 
            {
                RIssueTypeAttribute ria = (RIssueTypeAttribute)i.next();
                Group riaGroup = intake.get("RIssueTypeAttribute", 
                                 ria.getQueryKey(), false);
                Attribute attr = ria.getAttribute();
                if (attr.isOptionAttribute() && riaGroup.get("Required").toString().equals("true"))
                {
                    List options = issueType.getRIssueTypeOptions(ria.getAttribute(), true);
                    if (options == null || options.isEmpty())
                    if (issueType.getRIssueTypeOptions(attr, true).isEmpty())
                    {
                        scarabR.setAlertMessage(L10NKeySet.CannotRequireAttributeWithNoOptions);
                        success = false;
                    }
                }
            }
            i = rias.iterator();
            if (success)
            {
                while (i.hasNext()) 
                {
                    RIssueTypeAttribute ria = (RIssueTypeAttribute)i.next();
                    Group riaGroup = intake.get("RIssueTypeAttribute", 
                                     ria.getQueryKey(), false);
                    riaGroup.setProperties(ria);
                    String defaultTextKey = data.getParameters()
                        .getString("default_text");
                    if (defaultTextKey != null && 
                         defaultTextKey.equals(ria.getAttributeId().toString())) 
                    {
                        if (!ria.getRequired())
                        {
                            l10nMsg = l10n.get(L10NKeySet.ChangesSavedButDefaultTextAttributeRequired);
                        }
                        ria.setIsDefaultText(true);
                        ria.setRequired(true);
                        intake.remove(riaGroup);
                    }
                    ria.save();

                    // Set properties for attribute-attribute group mapping
                    RAttributeAttributeGroup raag = 
                        ag.getRAttributeAttributeGroup(ria.getAttribute());
                    Group raagGroup = intake.get("RAttributeAttributeGroup",
                                 raag.getQueryKey(), false);
                    raagGroup.setProperties(raag);
                    raag.save();
                }
                scarabR.setConfirmMessage(l10nMsg);
            }
        } 
        else
        {
            success = false;
            scarabR.setAlertMessage(l10nMsg);
        }
        return success;
    }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public void doDeleteattributes(RunData data, TemplateContext context) 
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Module module = scarabR.getCurrentModule();
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        String groupId = data.getParameters().getString("groupId");
        AttributeGroup ag = AttributeGroupManager
            .getInstance(new NumberKey(groupId), false);
        boolean hasAttributes = false;

        if (!user.hasPermission(ScarabSecurity.MODULE__EDIT, module))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }
        if (!ag.isGlobal() && issueType.getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        String key;
        String attributeId;
        ArrayList lockedAttrs = new ArrayList();

        for (int i =0; i<keys.length; i++)
        {
            key = keys[i].toString();
            if (key.startsWith("att_delete_"))
            {
                hasAttributes = true;
                attributeId = key.substring(11);
                Attribute attribute = AttributeManager
                   .getInstance(new NumberKey(attributeId), false);
                RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
                if (!ag.isGlobal() && ria != null &&  ria.getLocked())
                {
                    lockedAttrs.add(attribute);
                }
                else
                {
                    try
                    {
                        ag.deleteAttribute(attribute, user, module);
                    }
                    catch (ScarabException e)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(e));
                        Log.get().warn(
                            "This is an application error, if it is not permission related.", e);
                    }
                }
            }
        }
        if(!hasAttributes)
        {
            scarabR.setAlertMessage(L10NKeySet.NoAttributeSelected);
        }

        // If there are no attributes in any of the dedupe
        // Attribute groups, turn off deduping in the module
        boolean areThereDedupeAttrs = false;
        List attributeGroups = issueType.getAttributeGroups(module, true);
        if (attributeGroups.size() > 0)
        {
            for (int j=0; j<attributeGroups.size(); j++)
            {
                AttributeGroup agTemp = (AttributeGroup)attributeGroups.get(j);
                if (agTemp.getDedupe() && !agTemp.getAttributes().isEmpty())
                {
                   areThereDedupeAttrs = true;
                }
            }
            if (!areThereDedupeAttrs)
            {
                if (module == null)
                {
                    issueType.setDedupe(false);
                    issueType.save();
                }
                else
                {
                    RModuleIssueType rmit = module.getRModuleIssueType(issueType);
                    rmit.setDedupe(false);
                    rmit.save();
                }
            }
        }

        // If they attempted to modify locked attributes, give message.
        if (lockedAttrs.size() > 0)
        {
            setLockedMessage(lockedAttrs, context);
        }
        ScarabCache.clear();
        if(hasAttributes)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public void doCreatenewglobalattribute(RunData data,
                                            TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        Group attGroup = intake.get("Attribute", IntakeTool.DEFAULT_KEY);
        intake.remove(attGroup);
        scarabR.setAttribute(null);
        setTarget(data, getOtherTemplate(data));
    }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public void doSelectattribute(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        IssueType issueType = scarabR.getIssueType();
        if (issueType.isSystemDefined())
        {
            scarabR.setAlertMessage(L10NKeySet.SystemSpecifiedIssueType);
            return;
        }
        AttributeGroup ag = scarabR.getAttributeGroup();

        if (!ag.isGlobal() && scarabR.getIssueType().getLocked())
        {
            scarabR.setAlertMessage(L10NKeySet.LockedIssueType);
            return;
        }
        String[] attributeIds = data.getParameters()
                                    .getStrings("attribute_ids");
 
        if (attributeIds == null || attributeIds.length <= 0)
        { 
            scarabR.setAlertMessage(L10NKeySet.SelectAttribute);
            return;
        }
        else
        {
            boolean alreadySubmited = false;
            for (int i=0; i < attributeIds.length; i++)
            {
                Attribute attribute =
                    scarabR.getAttribute(new Integer(attributeIds[i]));
                try
                {
                    ag.addAttribute(attribute);
                }
                catch (TorqueException e)
                {
                    alreadySubmited = true;
                    scarabR.setAlertMessage(L10NKeySet.ResubmitError);
                }
            }
            doCancel(data, context);
            if (!alreadySubmited)
            {
                scarabR.setConfirmMessage(DEFAULT_MSG);
            }
        }
    }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
public void doDone (RunData data, TemplateContext context)
        throws Exception
    {
        String groupId = data.getParameters().getString("groupId");
        AttributeGroup ag = AttributeGroupManager
                            .getInstance(new NumberKey(groupId), false);
        boolean infoSuccess = doSaveinfo(data, context);
        boolean attrSuccess = false;
        if (ag.isGlobal())
        {
            attrSuccess = doSaveglobal(data, context);
        }
        else
        {
            attrSuccess = doSaveattributes(data, context);
        }
        if (infoSuccess && attrSuccess)
        {
            doCancel(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
private void setLockedMessage (List lockedAttrs, TemplateContext context)
        throws Exception
    {
        StringBuffer buf = new StringBuffer();
        for (int i=0; i<lockedAttrs.size(); i++)
        {
            Attribute attr = (Attribute)lockedAttrs.get(i);
            buf.append(attr.getName());
            if (i == lockedAttrs.size()-1)
            {
                buf.append(".");
            }
            else
            {
                buf.append(",");
            }
        }
        getScarabRequestTool(context).setAlertMessage(getLocalizationTool(context).format("LockedAttributes", buf.toString()));
    }
            
// in java/org/tigris/scarab/actions/admin/UpdateSearchIndex.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        LuceneSearchIndex index = SearchFactory.getInstance();
        
        if(isRunning)
        {
            isRunning = index.isRebuildInProgress();
            
            if(!isRunning)
                scarabR.setConfirmMessage( new L10NMessage( L10NKeySet.SearchIndexUpdated ));               
        }
        else
        {
            index.startRebuild();
            isRunning=true;
        }            

        if(isRunning){
            scarabR.setConfirmMessage( new L10NMessage( L10NKeySet.SearchIndexRebuildInProgress, index.pctRebuildFinished()));
            context.put("updateFrequency", "10" );
            context.put("rebuildInProgress", Boolean.TRUE);
        }

        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/admin/UpdateSearchIndex.java
public void doCancel(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        LuceneSearchIndex index = SearchFactory.getInstance();
        
        index.cancelRebuild();
        scarabR.setConfirmMessage( new L10NMessage( L10NKeySet.SearchIndexRebuildCancelled));
    
        String template = getCurrentTemplate(data, null);
        String nextTemplate = getNextTemplate(data, template);
        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/admin/GlobalEmailSettings.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        ParameterParser pp = data.getParameters();
        String name = null;
        for (int i=0; i < NAMES.length; i++) 
        {
            name = NAMES[i];
            GlobalParameterManager.setBoolean(name, pp.getBoolean(name));
        }
        // Note: name = GlobalParameter.EMAIL_ALLOW_MODULE_OVERRIDE
        if (!GlobalParameterManager.getBoolean(name)) 
        {
            // need to delete module overrides
            String sql = "delete from " + GlobalParameterPeer.TABLE_NAME 
                + " where " + GlobalParameterPeer.NAME + "='" + name 
                + "' and module_id is not null";
            GlobalParameterPeer.executeStatement(sql);
        }
        
        getScarabRequestTool(context).setConfirmMessage(DEFAULT_MSG);
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
public void doDelete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        IntakeTool intake = getIntakeTool(context);
        Group attrGroup = intake.get("ConditionEdit", IntakeTool.DEFAULT_KEY);
        data.getParameters().remove(attrGroup.get("ConditionsArray").getKey());
        updateObject(data, context, null);
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void delete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        int nObjectType = data.getParameters().getInt("obj_type");
        Criteria crit = new Criteria();
        switch (nObjectType)
        {
            case ScarabConstants.TRANSITION_OBJECT:
            	Integer tranId = data.getParameters().getInteger("transition_id");
            	crit.add(ConditionPeer.TRANSITION_ID, tranId);
            	TransitionManager.getMethodResult().remove(TransitionManager.getInstance(tranId), TransitionManager.GET_CONDITIONS);
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, 0);
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, 0);
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
        		crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, data.getParameters().getInt("module_id"));
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, data.getParameters().getInt("issueTypeId"));
        		break;
            case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabRequestTool scarabR = getScarabRequestTool(context);
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.deleteConditions(user, module);
                return;
        }
        ConditionPeer.doDelete(crit);
    	ConditionManager.clear();
    	TransitionManager.clear();
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void updateObject(RunData data, TemplateContext context, Integer aConditions[]) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Integer operator = data.getParameters().getInteger("combineWith");
        switch (data.getParameters().getInt("obj_type"))
        {
            case ScarabConstants.TRANSITION_OBJECT:
                Transition transition = scarabR.getTransition(data.getParameters().getInteger("transition_id"));
            	transition.setConditionsArray(aConditions, operator);
            	transition.save();
            	TransitionManager.getMethodResult().remove(transition, TransitionManager.GET_CONDITIONS);
                AttributeManager.clear();        
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                Attribute attribute = scarabR.getAttribute(data.getParameters().getInteger("attId"));
            	attribute.setConditionsArray(aConditions, operator);
            	attribute.save();
                AttributeManager.clear();        
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
            	RModuleAttribute rma = RModuleAttributePeer.retrieveByPK(data.getParameters().getInteger("moduleId"), data.getParameters().getInteger("attId"), data.getParameters().getInteger("issueTypeId"));
                rma.setConditionsArray(aConditions, operator);
                RModuleAttributeManager.clear();
                ConditionManager.clear();
                rma.save(); /** TODO: do we need it? **/
                AttributeManager.clear();        
        		break;
        	case ScarabConstants.BLOCKED_MODULE_ISSUE_TYPE_OBJECT:
        	    RModuleIssueType rmit = RModuleIssueTypePeer.retrieveByPK(scarabR.getCurrentModule().getModuleId(), data.getParameters().getInteger("issuetypeid"));
        		rmit.setConditionsArray(aConditions, operator);
        	    rmit.save();
        	    RModuleIssueTypeManager.clear();
        	    ConditionManager.clear();
                AttributeManager.clear();        
        	    break;
        	case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.saveConditions(user, module, aConditions, operator);
        	    break;
        }
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
public void doSave(RunData data, TemplateContext context) throws Exception
    {
        this.delete(data, context);
        IntakeTool intake = getIntakeTool(context);
        Group attrGroup = intake.get("ConditionEdit", IntakeTool.DEFAULT_KEY);
        Integer aConditions[] = ((Integer[])attrGroup.get("ConditionsArray").getValue());
        updateObject(data, context, aConditions);
            
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
public void doCancel(RunData data, TemplateContext context) throws Exception
    {
        String lastTemplate = getCancelTemplate(data);
        if (lastTemplate != null)
        {
            setTarget(data, lastTemplate);
        }
        else
        {
            super.doCancel(data, context);
        }
    }
            
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doGotoaddpermission(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,AddPermission.vm");
    }
            
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doGotodeletepermission(RunData data, TemplateContext context)
        throws Exception
    {
        setTarget(data, "admin,DeletePermission.vm");
    }
            
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doAddpermission(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        
        if (intake.isAllValid())
        {
            Object user = data.getUser().getTemp(ScarabConstants.SESSION_REGISTER);
            
            Group editPermission = null;
            if (user != null && user instanceof ScarabUser)
            {
                editPermission = intake.get("EditPermission", ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                editPermission = intake.get("EditPermission", IntakeTool.DEFAULT_KEY, false);
            }
            String name = editPermission.get("PermissionName").toString();
            
            try
            {        
                Permission permission = TurbineSecurity.getNewPermission(null);
                permission.setName(name);
                
                TurbineSecurity.addPermission(permission);
                data.getParameters().setString("lastAction", "addedpermission");
                String msg = l10n.format("PermissionCreated", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
            }
            catch (EntityExistsException eee)
            {
                String msg = l10n.format("PermissionExists", name);
                getScarabRequestTool(context).setConfirmMessage(msg);
                data.getParameters().setString("lastAction","");
            }
        }       
    }
            
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doDeletepermission(RunData data, TemplateContext context)
        throws Exception
    {
        String name = data.getParameters().getString("name");
        Permission permission = TurbineSecurity.getPermission(name);    
        TurbineSecurity.removePermission(permission);

        ScarabUserManager.getMethodResult().remove( ScarabUserManager.SCARAB_USER_IMPL, ScarabUserManager.ACL_HAS_PERMISSION );
        
        ScarabUserManager.getMethodResult().clear();

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String msg = l10n.format("PermissionDeleted", name);
        getScarabRequestTool(context).setConfirmMessage(msg);
        setTarget(data, data.getParameters().getString(ScarabConstants.NEXT_TEMPLATE, "admin,ManagePermissions.vm"));
        
    }
            
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doCancel(RunData data, TemplateContext context) throws Exception
    {
        setTarget(data, data.getParameters()
                      .getString(ScarabConstants.CANCEL_TEMPLATE, "admin,AdminIndex.vm"));
    }
            
// in java/org/tigris/scarab/actions/admin/ManagePermissions.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doCancel(data,context);
    }
            
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
public void doDeletenotifications( RunData data, TemplateContext context)
    throws Exception
    {                
        deleteMarkedEntries(data, context);
    }
            
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
private void deleteMarkedEntries(RunData data, TemplateContext context)
            throws Exception
    {
        Object[] keys = data.getParameters().getKeys();
        String key;
        String queryId;
        ScarabUser user = (ScarabUser) data.getUser();

        // loop over all notification ids contained in the
        // current parameter set. These notifications will
        // be removed from the Notificaiton List now without
        // rollback!
        for (int i = 0; i < keys.length; i++)
        {
            key = keys[i].toString();
            if (key.toLowerCase().startsWith("notificationid_"))
            {
                Object[] pkeys = extractPrimarykeys(key);
                Long tid    = (Long)pkeys[0];
                Integer cid = (Integer)pkeys[1];
                Integer rid = (Integer)pkeys[2];
                NotificationStatus ns = NotificationStatusPeer.retrieveByPK(tid,cid,rid);
                ns.markDeleted();
            }
        }
    }
            
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
public void doCustomize( RunData data, TemplateContext context)
    throws Exception
    {                
        customize(data, context);
    }
            
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
private void customize(RunData data, TemplateContext context) 
        throws Exception
    {
        String key;
        ScarabUser   user   = (ScarabUser) data.getUser();
        Integer userId = user.getUserId();

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module module = scarabR.getCurrentModule();
        Integer moduleId = module.getModuleId();
        
        
        // The ruleMap contains all rules for this user and this module
        NotificationRulePeer nfp = new NotificationRulePeer();
        Map<String, List<NotificationRule>> ruleMap = NotificationRulePeer.getCustomization(moduleId, userId);

        // The list of activityTypes
        ScarabGlobalTool scarabG = getScarabGlobalTool(context);
        List activityTypeList = scarabG.getAllNotificationTypeCodes();
        
        Iterator iter = activityTypeList.iterator();
        while(iter.hasNext())
        {
            String code = (String)iter.next();
            boolean theStatus      = data.getParameters().getBoolean(code+":status");
            boolean theSendSelf    = data.getParameters().getBoolean(code+":self");
            boolean theSendFailure = data.getParameters().getBoolean(code+":fail");
            Integer managerId      = NotificationManagerFactory.getInstance().getManagerId();
            
            NotificationRule rule = null;
            List<NotificationRule> rules = ruleMap.get(code);
            if(rules.size() == 0)
            {    
                rule = NotificationRule.createDefaultRule
                (
                    moduleId,
                    userId,
                    managerId,
                    code
                );
            }
            else
            {
                rule = rules.get(0);
            }
            markUpdateOrNew(rule);
            
            // adjust the new attribute values
            rule.setSendSelf(theSendSelf);
            rule.setSendFailures(theSendFailure);
            rule.setFilterState(theStatus);
            
            // finally modify in database.
            modifyInDatabase(rule);
        }
        scarabR.setConfirmMessage(L10NKeySet.ChangesSaved);
    }
            
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
private void modifyInDatabase(NotificationRule rule) throws TorqueException, Exception
    {
        if (equalsDefaultCustomization(rule))
        {
            if (rule.isNew())
            {
                // don't need to create this rule
            }
            else
            {
                // can safely remove this rule
                ObjectKey pk = rule.getPrimaryKey();
                NotificationRulePeer.doDelete(pk);
            }
         }
        else
        {
            // need to store this rule
            rule.save();
        }
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doAdd(RunData data, TemplateContext context) 
        throws Exception
    {
        int returnCode = 0;
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module module = scarabR.getCurrentModule();
        ParameterParser params = data.getParameters();
        StringBuffer msg = new StringBuffer();
        String[] userIds = params.getStrings(ADD_USER);
        Map<String,String> userAttributes = new HashMap<String,String>();
        if (userIds != null)
        {
            for (int i=0; i<userIds.length; i++)
            {
                String userId = userIds[i];
                if(userId.length() > 0)
                {
                    String attributeId = params.get("user_attr_" + userId);
                    if(attributeId == null)
                    {
                        attributeId = params.get("watcher_attr_" + userId);
                    }
                    if(attributeId == null)
                    {
                        // The specified userid has not been associated to any userAttribute
                        // This happens typically if the specified userId does not exist,
                        // or the userid has no permission to be assigned to this issue.
                        // This can only be an application error (in the velocity templates)
                        // Scarab drops the userID and does not assign a userAttribute
                        // for this user to the issue.
                        
                        scarabR.setAlertMessage("Illegal attempt to assign user with id ["+userId+"] to a new issue. Probably this is a wrong automation setting. Please Check your javascript observers!");
                    }
                    else
                    {
                        userAttributes.put(userId, attributeId);
                    }
                }
                else
                {
                    //The user has selected the "select user..." option, which itself is empty
                }
            }
            returnCode = addUsersToList(user, module, userAttributes, msg);        
            setGUIMessage(returnCode, scarabR, msg);
        }
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doAddmyself(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        ScarabUser user = (ScarabUser)data.getUser();
        
        // clean up first. I may already be in the list
        // [HD]Note: Here i assume, that one user may only show up ONCE
        //     in the list. Apparently it does not make sense to
        //     assign someone AND let the same person observe an issue
        //     at the same time. But OTOH it might be possible, that
        //     other use cases exist, which make it necessary to
        //     have multiple assignments of the same user in the list.
        //     (to be discussed?)
        removeUserFromIssue(user, issue); 

        String attributeId = data.getParameters().get("myself_attribute");
        String userId = user.getUserId().toString();
        Map map = new HashMap();
        map.put(userId, attributeId);
        StringBuffer msg = new StringBuffer();
        int returnCode = addUsersToList(user, scarabR.getCurrentModule(), map, msg);
        setGUIMessage(returnCode, scarabR, msg);       
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doRemovemyself(RunData data, TemplateContext context)
    throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);
        ScarabUser user = (ScarabUser) data.getUser();
        Issue issue = scarabR.getIssue();
        int removeCounter = removeUserFromIssue(user, issue);
        if(removeCounter>0)
        {
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereRemoved);
        }
        else
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
private int addUsersToList(ScarabUser user, Module module, Map userAttributes, StringBuffer msg) throws Exception, TorqueException
    {
        int returnCode;
        Map userMap = user.getAssociatedUsersMap();
        if (userAttributes != null && userAttributes.size() > 0) 
        {
            boolean isUserAttrRemoved = false;
            List removedUserAttrs = null;
            for (Iterator it = userAttributes.keySet().iterator(); it.hasNext(); )
            {
                String userId = (String)it.next();
                List item = new ArrayList();
                String attrId = (String)userAttributes.get(userId);
                Attribute attribute = AttributeManager
                    .getInstance(new Integer(attrId));
                ScarabUser su = ScarabUserManager
                    .getInstance(new Integer(userId));
                item.add(attribute);
                item.add(su);
                List issues = (List)user.getAssignIssuesList();
                for (int j=0; j<issues.size(); j++)
                {
                    Issue issue = (Issue)issues.get(j);
                    Long issueId = issue.getIssueId();
                    Set userList = (Set) userMap.get(issueId);
                    if (userList == null)
                    {
                        userList = new HashSet();
                    }
                    List<Attribute> attributeList = module
                        .getUserAttributes(issue.getIssueType(), true);
                    if (!attributeList.contains(attribute))
                    {
                        if (removedUserAttrs == null)
                        {
                            removedUserAttrs = new ArrayList();
                            removedUserAttrs.add(attribute);
                            msg.append("'").append(attribute.getName())
                                .append("'");
                        }
                        else if (!removedUserAttrs.contains(attribute))
                        {
                            removedUserAttrs.add(attribute);
                            msg.append(", '").append(attribute.getName())
                                .append("'");
                        }
                        isUserAttrRemoved = true;
                    }
                    else
                    {
                        removeUserFromUserSet(su, null, userList); // remove all user entries from set.
                        cleanupMultiAssignEntries(attribute, userList, attributeList);
                        userList.add(item);
                        // userMap.put(issueId, userList);
                        // user.setAssociatedUsersMap(userMap);
                    }
                } 
            }
            if (!isUserAttrRemoved)
            {
                returnCode = USERS_ADDED;
            }
            else 
            {
                returnCode = USERS_REMOVED;
            }
        }
        else
        {
            returnCode = ERR_NO_USERS_SELECTED;
        }
        return returnCode;
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
private void remove(RunData data, TemplateContext context, Long issueId) 
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Set userSet = (Set) user.getAssociatedUsersMap().get(issueId);
        ParameterParser params = data.getParameters();
        String[] selectedUsers =  params.getStrings(SELECTED_USER);
        if (selectedUsers != null && selectedUsers.length > 0) 
        {
            for (int i =0; i<selectedUsers.length; i++)
            {
                List item = new ArrayList(2);
                String selectedUser = selectedUsers[i];
                String userId = selectedUser.substring(1, selectedUser.indexOf('_')-1);
                String attrId = selectedUser.substring(selectedUser.indexOf('_')+1, selectedUser.length());
                Attribute attribute = AttributeManager.getInstance(new Integer(attrId));
                ScarabUser su = ScarabUserManager.getInstance(new Integer(userId));
                Issue issue = IssueManager.getInstance(issueId);
                removeUserFromUserSet(su, attribute, userSet);
            }
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereRemoved);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
private void update(RunData data, TemplateContext context, Long issueId) 
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Set userList = (Set) user.getAssociatedUsersMap().get(issueId);
        ParameterParser params = data.getParameters();
        String[] selectedUsers =  params.getStrings(SELECTED_USER);
        
        if (selectedUsers != null && selectedUsers.length > 0) 
        {
            Issue issue = IssueManager.getInstance(issueId);
            Module module = issue.getModule();
            List<Attribute> attributeList = module.getUserAttributes(issue.getIssueType(), true);
            for (int i =0; i < selectedUsers.length; i++)
            {
                String selectedUser = selectedUsers[i];
                String userId = selectedUser.substring(1, selectedUser.indexOf('_')-1);
                String attrId = selectedUser.substring(selectedUser.indexOf('_')+1, selectedUser.length());
                Attribute attribute = AttributeManager.getInstance(new Integer(attrId));
                ScarabUser su = ScarabUserManager.getInstance(new Integer(userId));

                removeUserFromUserSet(su, attribute, userList);
                
                List newItem = new ArrayList(2);
                String newKey = "asso_user_{" + userId + "}_attr_{" + attrId + "}_issue_{" + issueId + '}';
                String newAttrId = params.get(newKey);
                Attribute newAttribute = AttributeManager.getInstance(new Integer(newAttrId));
                cleanupMultiAssignEntries(newAttribute, userList, attributeList);

                newItem.add(newAttribute);
                newItem.add(su);
                
                userList.add(newItem);
            }
            scarabR.setConfirmMessage(L10NKeySet.SelectedUsersWereModified);
        }
        else 
        {
            scarabR.setAlertMessage(L10NKeySet.NoUsersSelected);
        }
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        List issues = null;
        String singleIssueId = data.getParameters().getString("id");
        if (singleIssueId != null)
        {
            Issue issue = scarabR.getIssue(singleIssueId);
            if (issue != null)
            {
                issues = new ArrayList();
                issues.add(issue);
            }
        }
        else
        {
            issues = (List)((ScarabUser)data.getUser()).getAssignIssuesList();
        }

        Map userMap = user.getAssociatedUsersMap();
        ScarabUser assigner = (ScarabUser)data.getUser();
        String reason = data.getParameters().getString("reason", "");
        Attachment attachment = null;
        ActivitySet activitySet = null;
        boolean isUserAttrRemoved = false;
        StringBuffer msg = new StringBuffer();
        List removedUserAttrs = null;

        for (int i=0; i < issues.size(); i++)
        {
            Issue issue = (Issue)issues.get(i);
            Set userList = (Set) userMap.get(issue.getIssueId());
            List oldAssignees = issue.getUserAttributeValues();
            List attributeList = scarabR.getCurrentModule()
                                .getUserAttributes(issue.getIssueType(), true);
            // save attachment with user-provided reason
            if (reason != null && reason.length() > 0)
            {
                attachment = new Attachment();
                attachment.setData(reason);
                attachment.setName("comment");
                attachment.setTextFields(assigner, issue,
                                         Attachment.MODIFICATION__PK);
                attachment.save();
            }

            // loops through users in temporary working list
            for (Iterator iter = userList.iterator(); iter.hasNext();)
            {
                List item = (List)iter.next();
                Attribute newAttr = (Attribute)item.get(0);
                ScarabUser assignee = (ScarabUser)item.get(1);
                Integer assigneeId = assignee.getUserId();
                boolean alreadyAssigned = false;
                if (!attributeList.contains(newAttr))
                {
                    if (removedUserAttrs == null)
                    {
                        removedUserAttrs = new ArrayList();
                        removedUserAttrs.add(newAttr);
                        msg.append("'").append(newAttr.getName()).append("'");
                    }
                    else if (!removedUserAttrs.contains(newAttr))
                    {
                        removedUserAttrs.add(newAttr);
                        msg.append(", '").append(newAttr.getName()).append("'");
                    }
                    isUserAttrRemoved = true;
                }
                else
                {
                    for (int k=0; k < oldAssignees.size(); k++)
                    {
                            AttributeValue oldAttVal = (AttributeValue)
                                                        oldAssignees.get(k);
                        Attribute oldAttr = oldAttVal.getAttribute();
                        // ignore already assigned users
                        if (assigneeId.equals(oldAttVal.getUserId()))
                        {
                            // unless user has different attribute id, then
                            // switch their user attribute
                                if (!newAttr.getAttributeId().equals(
                                                oldAttr.getAttributeId()))
                            {
                                List tmpItem = new ArrayList();
                                tmpItem.add(newAttr);
                                tmpItem.add(assignee);
                                if (!userList.contains(tmpItem))
                                {
                                    alreadyAssigned = true;
                                    activitySet = issue.changeUserAttributeValue(
                                                          activitySet, assignee,
                                                          assigner, oldAttVal,
                                                          newAttr, attachment);
                                }
                            }
                            else
                            {
                                alreadyAssigned = true;
                            }
                        }
                    }
                    // if user was not already assigned, assign them
                    if (!alreadyAssigned)
                    {
                            activitySet = issue.assignUser(activitySet, assignee,
                                        assigner, newAttr, attachment);
                    }
                }
            }

            // loops thru previously assigned users to find ones that
            // have been removed
            for (int m=0; m < oldAssignees.size(); m++)
            {
                boolean userStillAssigned = false;
                AttributeValue oldAttVal = (AttributeValue)oldAssignees.get(m);
                for (Iterator iter = userList.iterator(); iter.hasNext();)
                {
                    List item = (List)iter.next();
                    Attribute attr = (Attribute)item.get(0);
                    ScarabUser su = (ScarabUser)item.get(1);
                    if (su.getUserId().equals(oldAttVal.getUserId())
                        && attr.getAttributeId().equals(oldAttVal.getAttributeId()))
                    {
                         userStillAssigned = true;
                    }
                }
                if (!userStillAssigned)
                {
                    ScarabUser assignee = scarabR.getUser(oldAttVal.getUserId());
                    // delete the user
                    activitySet = issue.deleteUser(activitySet, assignee, 
                                                   assigner, oldAttVal, attachment);
                }
            }
            if (activitySet != null) {
                try
                {
                    NotificationManagerFactory.getInstance()
                            .addActivityNotification(
                                    ActivityType.USER_ATTRIBUTE_CHANGED,
                                    activitySet, issue, user);
                }
                catch(Exception e)
                {
                    L10NMessage l10nMessage = new L10NMessage(EMAIL_ERROR,e);
                    scarabR.setAlertMessage(l10nMessage);
                }
            }
        }
        if (isUserAttrRemoved)
        {
            L10NMessage l10nMsg = new L10NMessage(L10NKeySet.UserAttributeRemoved,
                                                  msg.toString());
            scarabR.setAlertMessage(l10nMsg);
        }
        
        Object alertMessage = scarabR.getAlertMessage();
        if (alertMessage == null || 
            alertMessage.toString().length() == 0)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
        }
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
public void doPerform(RunData data, TemplateContext context) 
        throws Exception
    {
        
        Object[] keys =  data.getParameters().getKeys();
        try
        {
            for (int i =0; i<keys.length; i++)
            {
                String key = keys[i].toString();
                if (key.startsWith("eventsubmit_doremove"))
                {
                    String issueId = key.substring(21);
                    remove(data, context, new Long(issueId));
                }
                else if (key.startsWith("eventsubmit_doupdate"))
                {
                    String issueId = key.substring(21);
                    update(data, context, new Long(issueId));
                }
            }
        }
        catch (NumberFormatException nfe) // new Integer(issueId) above could fail
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.BadIntegerConversion);
        }
    }
            
// in java/org/tigris/scarab/actions/Redirect.java
public void doRedirect(RunData data, TemplateContext context)
        throws Exception
    {
        // set the next template
        String nextTemplate = data.getParameters()
            .getString(ScarabConstants.NEXT_TEMPLATE, 
                       ((ScarabUser)data.getUser()).getHomePage());

        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/Redirect.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doRedirect(data, context);
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doAddwatchers(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);
        
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssue();
        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                               issue.getModule()))
        {
            // We'll set the info required by AssignIssue.doAddmyself (the)
            // same that in doEditassignees in this same class.
            data.getParameters().add("id", issue.getUniqueId());
            data.getParameters().add("issue_ids", issue.getUniqueId());
            String watcher = data.getParameters().get("add_watcher");
            data.getParameters().remove("add_user");
            data.getParameters().add("add_user", watcher);

            scarabR.resetAssociatedUsers();
            
            // Lets cross-call the AssignIssue Turbine action!
            AssignIssue assignAction = new AssignIssue();
            assignAction.doAdd(data, context);
            assignAction.doDone(data, context);
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }        
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSubmitattributes(RunData data, TemplateContext context)
        throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }

        final ScarabRequestTool scarabR = getScarabRequestTool(context);
        final ScarabLocalizationTool l10n = getLocalizationTool(context);
        final Issue issue = scarabR.getIssue();
        final Module module = scarabR.getCurrentModule();

        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        final ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        final IntakeTool intake = getIntakeTool(context);
        
        final boolean isReasonRequired = module.isIssueReasonRequired();
        
        // Reason field is required to modify attributes
        final Group reasonGroup = intake.get("Attachment", "attCommentKey" + issue.getQueryKey(), false);
        REASON_SAVE_MODE reasonSaveMode = saveReason(data, isReasonRequired, reasonGroup);

        // Set any other required flags
        final Map selectedOptions = new HashMap();
        final Map conditionallyRequiredFields = new HashMap(); 
        final IssueType issueType = issue.getIssueType();
        final List requiredAttributes = issueType
            .getRequiredAttributes(issue.getModule());
        final LinkedMap modMap = issue.getModuleAttributeValuesMap();
        
        boolean localFieldErrors = false;
        for (Iterator iter = modMap.mapIterator(); iter.hasNext(); ) 
        {
            final AttributeValue aval = (AttributeValue)modMap.get(iter.next());
            final Group group = intake.get("AttributeValue", aval.getQueryKey(), false);
            Field field = null;
            if (group != null) 
            {   
                if (aval instanceof OptionAttribute) 
                {
                    // use optionId instead
                    field = group.get("OptionId");
                    // Will store the selected optionId, for later query against conditions.
                    Object fieldValue = field.getValue();
                    if (null != fieldValue)
                    {
                        selectedOptions.put(fieldValue, field);
                    }
                    
                }
                else if(aval instanceof IntegerAttribute)
                {
                    field = group.get("NumericValue");
                }
                else
                {
                    field = group.get("Value");
                }
                
                Object fieldValue = field.getValue();
                if(fieldValue != null)
                {
                    String fieldValueAsString = fieldValue.toString();
                    if (fieldValueAsString != null && fieldValueAsString.length() > 0) 
                    {
                        boolean exactMatch = true;
                        String pattern = aval.getAttribute().getFormat();
                        String hint = aval.getAttribute().getHint();
                        if (pattern != null && pattern.length() > 0) 
                        {
                            RegexProcessor processor = new RegexProcessor();
                            exactMatch = processor.matches(fieldValueAsString, pattern);
                        }
                        if (!exactMatch) 
                        {
                            if (hint == null || hint.length() == 0)
                                hint = pattern;
                            String[] parameters = new String[] 
                            {
                                    aval.getAttribute().getName(),
                                    fieldValue.toString(), pattern, hint };
                            LocalizationKey key;
                            if (fieldValueAsString.equals(hint)) {
                                key = L10NKeySet.UnprocessedField;
                            } else {
                                key = L10NKeySet.InvalidFieldFormat;
                            }
                            L10NMessage l10nMessage = new L10NMessage(key,
                                    parameters);
                            field.setMessage(l10nMessage.getMessage(l10n));
                            localFieldErrors = true;
                        }
                    }
                }
                
                // check required attributes
                for (int j=requiredAttributes.size()-1; j>=0; j--) 
                {
                    if (aval.getAttribute().getPrimaryKey().equals(
                         ((Attribute)requiredAttributes.get(j)).getPrimaryKey())) 
                    {
                        field.setRequired(true);
                        break;
                    }                    
                }                
            }
            /**
             * If the field has any conditional constraint, will be added to the collection for later query.
             */ 
            final List conditions = aval instanceof UserAttribute
                    ? aval.getAttribute().getConditions()
                    : aval.getRModuleAttribute().getConditions(); 
            if (conditions.size() > 0)
            {
                for (Iterator it = conditions.iterator(); it.hasNext(); )
                {
                    final Condition cond = (Condition)it.next();
                    final Integer id = cond.getOptionId();
                    List fields = (List)conditionallyRequiredFields.get(id);
                    if (fields == null)
                    {
                        fields = new ArrayList();
                    }
                    fields.add( field!=null ? (Object)field : (Object)aval ); // !breaks any generics on this list!
                    conditionallyRequiredFields.put(id, fields);
                }
            }
                
        }

        final boolean attributeValuesValid = submitattributesCheckRequiredAttributes(
                issue, conditionallyRequiredFields, selectedOptions);

        if (intake.isAllValid() && attributeValuesValid && !localFieldErrors) 
        {
            submitattributesPerform(context, user, data, reasonSaveMode);
        } 
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
            // were obviously in editing mode
            data.getParameters().setString("edit_attributes", "true");
            // preserve fullcomments mode
            data.getParameters().setString("fullcomments", data.getParameters().get("fullcomments"));
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
private boolean submitattributesCheckRequiredAttributes(
                final Issue issue,
                final Map conditionallyRequiredFields,
                final Map selectedOptions)
            throws Exception
    {
        boolean attributeValuesValid = true;
        for (Iterator requiredIds = conditionallyRequiredFields.keySet().iterator(); requiredIds.hasNext(); )
        {
            final Integer attributeId= (Integer)requiredIds.next();
            if (selectedOptions.keySet().contains(attributeId))
            {
                final List fields = (List)conditionallyRequiredFields.get(attributeId);
                for (Iterator iter = fields.iterator(); iter.hasNext(); )
                {
                    final Object next = iter.next();
                    if( next instanceof Field )
                    {
                        final Field field = (Field)next;
                        if(null == field.getValue() || field.getValue().toString().length() == 0)
                        {
                            field.setRequired(true);
                            field.setMessage("ConditionallyRequiredAttribute");
                        }
                    }
                    else if(next instanceof UserAttribute)
                    {
                        // An attribute that doesn't exist in intake needs to be 
                        //  added to this issue. 
                        // Currently only UserAttributes exists in this category.
                        final UserAttribute originalAv = (UserAttribute)next;
                        // get attribute value from issue to avoid cached value from intake
                        final UserAttribute freshAv = 
                                (UserAttribute)issue.getAttributeValue(
                                    originalAv.getAttribute());
                        
                        if(freshAv == null || freshAv.getValue() == null)
                        {
                            
                            final AttributeOption option =
                                    AttributeOptionManager.getInstance(attributeId);
                            // Will append the error message to the attribute the user 
                            //  is trying to change instead, since the user attributes
                            // are on a different part/tab on the screen.
                            final Field f = (Field)selectedOptions.get(attributeId);
                            final L10NMessage msg = new L10NMessage(
                                    L10NKeySet.ConditionallyRequiredUserAttribute, 
                                    new Object[]
                                    {
                                        // use original attribute value and it won't be null
                                        originalAv.getAttribute().getName(),
                                        option.getName()
                                    }
                            );
                            f.setMessage(msg.getMessage());
                            attributeValuesValid = false;
                        }
                    }
                }
            }
        }
        return attributeValuesValid;
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
private void submitattributesPerform(
                final TemplateContext context,
                final ScarabUser user,
                RunData runData,
                REASON_SAVE_MODE saveMode)
            throws Exception
    {
        
        // get required tools
        final ScarabRequestTool scarabR = getScarabRequestTool(context);
        final ScarabLocalizationTool l10n = getLocalizationTool(context);
        final Issue issue = scarabR.getIssue();
        final LinkedMap modMap = issue.getModuleAttributeValuesMap();
        final IntakeTool intake = getIntakeTool(context);
        final Group reasonGroup = intake.get("Attachment", "attCommentKey" + issue.getQueryKey(), false);
        
        // start building attribute maps holding the changes
        final HashMap newAttVals = new HashMap();
        // Set the attribute values entered 
        final Iterator iter2 = modMap.mapIterator();
        boolean modifiedAttribute = false;
        
        String assignActiveUser = runData.getParameters().get("add_user");
        if(assignActiveUser != null && assignActiveUser.length() > 0)
        {
            scarabR.resetAssociatedUsers();
            
            // Lets cross-call the AssignIssue Turbine action!
            AssignIssue assignAction = new AssignIssue();
            assignAction.doAdd(runData, context);
            assignAction.doSave(runData, context);
            modifiedAttribute = true;
        }
        
        String assignWatcherUser = runData.getParameters().get("add_watcher");
        if(assignWatcherUser != null && assignWatcherUser.length() > 0)
        {
            doAddwatchers(runData, context);
        }
        
        Attribute myOnHoldDateAttribute = issue.getMyOnHoldExpirationDate();
        Attribute statusAttribute       = issue.getMyStatusAttribute();
        boolean statusChanged = false;
        boolean onHoldDateSet = false;
        boolean isOnHold      = issue.isOnHold();

        while (iter2.hasNext())
        {
            final AttributeValue aval = (AttributeValue)modMap.get(iter2.next());
            final AttributeValue aval2 = AttributeValue.getNewInstance(aval.getAttributeId(), 
                                                  aval.getIssue());
            aval2.setProperties(aval);

            final Group group = intake.get("AttributeValue", aval.getQueryKey(), false);
            String oldValue = "";
            String newValue = "";

            if (group != null) 
            {            
                if (aval instanceof OptionAttribute) 
                {
                    newValue = group.get("OptionId").toString();
                    oldValue = aval.getOptionIdAsString();
                }
                else if (aval instanceof DateAttribute)
                {
                    newValue = DateAttribute.internalDateFormat(
                            group.get("Value").toString(),
                            l10n.get(L10NKeySet.ShortDatePattern));
                    oldValue = aval.getValue();
                }
                else if (aval instanceof IntegerAttribute)
                {
                    newValue = group.get("NumericValue").toString();
                    oldValue = null != aval.getNumericValue() 
                            ? aval.getNumericValue().toString()
                            : "";
                    // mirror the numeric_value into the value field
                    aval2.setValue(newValue);
                }
                else 
                {
                    newValue = group.get("Value").toString();
                    oldValue = aval.getValue();
                }
                // A value has been entered for the attribute.
                // The old value is different from the new, or is unset:
                // Set new value.
                if (newValue.length() > 0
                     && ((oldValue == null) ||
                        (oldValue != null && !oldValue.trim().equals(newValue.trim()))))
                {
                    group.setProperties(aval2);
                    newAttVals.put(aval.getAttributeId(), aval2);
                    modifiedAttribute = true;

                    Attribute att = aval.getAttribute();
                    if(att.equals(statusAttribute))
                    {
                        statusChanged = true;
                    }
                    else if (att.equals(myOnHoldDateAttribute))
                    {
                        onHoldDateSet = true;
                    }
                }
                // The attribute is being undefined. 
                else if (oldValue != null && newValue.length() == 0 && 
                         oldValue.length() != 0)
                {
                    aval2.setValue(null);
                    newAttVals.put(aval.getAttributeId(), aval2);
                    modifiedAttribute = true;
                }
            }
        } 
        
        if (!modifiedAttribute && saveMode!=REASON_SAVE_MODE.NONE)
        {
            scarabR.setAlertMessage(L10NKeySet.MustModifyAttribute);
            runData.getParameters().setString("edit_attributes", "true"); // force edit
            return;
        }
        final Attachment attachment = AttachmentManager.getInstance();
        reasonGroup.setProperties(attachment);

        try
        {
            DateAttribute.convertDateAttributes(newAttVals.values(), 
                    l10n.get(L10NKeySet.ShortDatePattern));                
            final ActivitySet activitySet = issue.setAttributeValues(null, 
                    newAttVals, attachment, user);
            // save reason as a comment as well?
            if(saveMode!=REASON_SAVE_MODE.NONE)
            {
                if( saveMode == REASON_SAVE_MODE.COMMENT )
                {
                    issue.addComment(activitySet, attachment, user);
                }
                else
                {
                    NotificationManagerFactory.getInstance().addActivityNotification(
                                    ActivityType.ATTRIBUTE_CHANGED,
                                    activitySet, issue, user);
                }
                
                if (statusChanged)
                {
                    if(isOnHold)
                    {
                        // ok, the issue was on hold, but now the status has changed.
                        // Hence we must cancel a previous onHoldNotification now.
                        NotificationManagerFactory.getInstance().cancelOnHoldNotification(issue);
                    }
                    else if(issue.isOnHold())
                    {
                        // From the boolean isOnHold==false we deduce that the issue was NOT on hold
                        // prior to this transaction. But from the issue.isOnHold()==true we deduce
                        // that now it IS on hold. Hence the status must have changed during this transaction
                        // from something to onHold.
                        //
                        // And now is the time to create another notification which will be used as wakeup
                        // Notification when the onHoldDate expires. This information must be handled
                        // by the NotificationManager (see the NotificationManager.wakeupOnHoldTimeouts() )
                        NotificationManagerFactory.getInstance().addOnHoldNotification(activitySet, issue, user);
                    }
                }

                
                
            }
            intake.removeAll();
            scarabR.setConfirmMessage(L10NKeySet.ChangesSaved);
        }
        catch (Exception se)
        {
            scarabR.setAlertMessage(l10n.getMessage(se));
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSaveurl (RunData data, TemplateContext context) 
        throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        ScarabUser user = (ScarabUser)data.getUser();

        List urls = issue.getUrls();
        ActivitySet activitySet = null;
        for (int i = 0; i<urls.size(); i++)
        {
            Attachment attachment = (Attachment)urls.get(i);
            if (attachment.getTypeId().equals(Attachment.URL__PK)
                && !attachment.getDeleted())
            {
                Group group = intake.get("Attachment", attachment.getQueryKey(), false);

                Field nameField = group.get("Name"); 
                Field dataField = group.get("Data"); 
                if (dataField.isValid())
                {
                    dataField.setRequired(true);
                }
                
                if (intake.isAllValid())
                {
                    // store the new and old data
                    String oldDescription = attachment.getName();
                    String oldURL = new String(attachment.getData());
                    String newDescription = nameField.toString();
                    String newURL = dataField.toString();

                    if (!oldDescription.equals(newDescription))
                    {
                        group.setProperties(attachment);
                        attachment.save();
                        activitySet = issue
                            .doChangeUrlDescription(activitySet, user, 
                                                    attachment, oldDescription);
                        scarabR.setConfirmMessage(L10NKeySet.UrlSaved);
                    }
                    if (!oldURL.equals(newURL))
                    {
                        group.setProperties(attachment);
                        attachment.save();
                        activitySet = issue
                            .doChangeUrlUrl(activitySet, user, 
                                            attachment, oldURL);
                        scarabR.setConfirmMessage(L10NKeySet.UrlSaved);
                    }
                }
                else
                {
                     scarabR.setAlertMessage(ERROR_MESSAGE);
                }
            }
        }

        // if there is a new URL, add it
        Group newGroup = intake.get("Attachment", "urlKey", false);
        if (newGroup != null)
        { 
            Field dataField = newGroup.get("Data");
            String dataFieldString = dataField.toString();
            if (dataFieldString != null && dataFieldString.trim().length() > 0)
            {
                if (intake.isAllValid())
                {
                    // create the new attachment
                    Attachment attachment = AttachmentManager.getInstance();
                    // set the form data to the attachment object
                    newGroup.setProperties(attachment);
                    activitySet = issue.addUrl(attachment, user);

                    // remove the group
                    intake.remove(newGroup);
                    scarabR.setConfirmMessage(L10NKeySet.UrlSaved);
                    NotificationManagerFactory.getInstance()
                            .addActivityNotification(
                                    ActivityType.URL_ADDED, activitySet,
                                    issue,
                                    user);
                }
                else
                {
                     scarabR.setAlertMessage(ERROR_MESSAGE);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doEditcommentpage(RunData data, TemplateContext context)
         throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        if (!user.hasPermission(ScarabSecurity.ISSUE__COMMENT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }
        data.getParameters().add("edit_comments", "true");
        data.getParameters().add("fullcomments", data.getParameters().get("fullcomments"));
        return;
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doEditattributespage(RunData data, TemplateContext context)
         throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }
        data.getParameters().setString("edit_attributes", "true");
        data.getParameters().setString("fullcomments", data.getParameters().get("fullcomments"));
        return;
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSubmitcomment (RunData data, TemplateContext context) 
         throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__COMMENT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        Group group = intake.get("Attachment", "commentKey", false);
        if (group != null) 
        {
            Attachment attachment = AttachmentManager.getInstance();
            try
            {
                group.setProperties(attachment);
            }
            catch (Exception e)
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
                return;
            }
            
            try
            {
                issue.addComment(attachment, (ScarabUser)data.getUser());
            }
            catch(Exception e)
            {
                String l10nMessage = l10n.getMessage(e);
                scarabR.setAlertMessage(l10nMessage);
                return;
            }
            scarabR.setConfirmMessage(L10NKeySet.CommentSaved);
            intake.remove(group);
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSubmitfile (RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__ATTACH, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        Group group = intake.get("Attachment", "fileKey" + issue.getQueryKey(), false);
        Field nameField = group.get("Name"); 
        // set some required fields
        if (nameField.isValid())
        {
            nameField.setRequired(true);
        }
        // validate intake
        if (intake.isAllValid() && group != null)
        {
            // adding a file is a special process
            addFileAttachment(issue, group, (Attachment) null, scarabR, data,
                              intake);
            ActivitySet activitySet = issue.doSaveFileAttachments(user);
            if (activitySet != null)
            {
                scarabR.setConfirmMessage(L10NKeySet.FileSaved);
                NotificationManagerFactory.getInstance()
                        .addActivityNotification(
                                ActivityType.ATTACHMENT_CREATED,
                                activitySet, issue, user);
                
            }
            else
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
            }
        }
        else
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
static void addFileAttachment(Issue issue, Group group,
                                  Attachment attachment,
                                  ScarabRequestTool scarabR, RunData data,
                                  IntakeTool intake)
        throws Exception
    {
        if (group != null)
        {
            Field nameField = group.get("Name");
            Field fileField = group.get("File");
            nameField.setRequired(true);
            fileField.setRequired(true);
            Field mimeAField = group.get("MimeTypeA");
            Field mimeBField = group.get("MimeTypeB");
            String mimeA = mimeAField.toString();
            String mimeB = mimeBField.toString();
            String mimeType = null;
            if (mimeB != null && mimeB.trim().length() > 0)
            {
                mimeType = mimeB;
            }
            else if ("autodetect".equals(mimeA) && fileField.isValid())
            {
                try 
                {
                    String filename = 
                        ((FileItem)fileField.getValue()).getName();
                    String contentType = 
                        ComponentLocator.getMimeTypeService().getContentType(filename, null);
                    if (contentType == null) 
                    {
                        // could not match extension.
                        mimeAField
                            .setMessage("intake_CouldNotDetermineMimeType");
                    }
                    else 
                    {
                        mimeType = contentType;
                    }
                }
                catch (Exception e)
                {
                    // we do not want any exception thrown here to affect
                    // the user experience, it is just considered a 
                    // non-detectable file type.  But still the exception is
                    // not expected, so log it.
                    mimeAField.setMessage("intake_CouldNotDetermineMimeType");
                    Log.get().info(
                        "Could not determine mimetype of uploaded file.", e);
                }                
            }
            else
            {
                mimeAField.setRequired(true);
                mimeType = mimeA;
            }
            if (group.isAllValid()) 
            {
                if (attachment == null)
                {
                    attachment = AttachmentManager.getInstance();
                }
                group.setProperties(attachment);
                attachment.setMimeType(mimeType);
                issue.addFile(attachment, (ScarabUser)data.getUser());
                // remove the group so that the form data doesn't show up again
                intake.remove(group);
            }
            else
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
            }
        }
        else
        {
            scarabR.setAlertMessage(L10NKeySet.CouldNotLocateAttachmentGroup);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doEditcomment (RunData data, TemplateContext context)
        throws Exception
    {                          
        if (isCollision(data, context)) 
        {
            return;
        }
        
        ScarabUser user = (ScarabUser)data.getUser();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        if (!user.hasPermission(ScarabSecurity.ISSUE__COMMENT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        ActivitySet activitySet = null;
        for (int i=0; i<keys.length; i++)
        {
            String key = (String) keys[i];
            if (key.startsWith("edit_comment_"))
            {
                String attachmentId = key.substring(13);
                String newComment = params.getString(key,"");
                Attachment attachment = AttachmentManager
                    .getInstance(new NumberKey(attachmentId), false);
                try
                {
                    activitySet = issue.doEditComment(activitySet, newComment, 
                                                      attachment, user);
                }
                catch (ScarabException se)
                {
                    scarabR.setAlertMessage(l10n.getMessage(se));
                }
            }
        }
        if (activitySet != null)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);  
        }
        else
        {
            scarabR.setInfoMessage(L10NKeySet.NoCommentsChanged);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doDeleteurl (RunData data, TemplateContext context)
        throws Exception
    {                          
        if (isCollision(data, context)) 
        {
            return;
        }
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        ActivitySet activitySet = null;
        for (int i=0; i < keys.length; i++)
        {
            String key = (String) keys[i];
            if (key.startsWith("url_delete_"))
            {
                String attachmentId = key.substring(11);
                Attachment attachment = AttachmentManager
                    .getInstance(new NumberKey(attachmentId), false);
                activitySet = issue.doDeleteUrl(activitySet, attachment, user);
            }
        }
        if (activitySet != null)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_DELETED, activitySet, issue, user);
        }
        else
        {
            scarabR.setInfoMessage(L10NKeySet.NoUrlsChanged);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doDeletefile (RunData data, TemplateContext context)
        throws Exception
    {      
        if (isCollision(data, context)) 
        {
            return;
        }
        
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        ActivitySet activitySet = null;

        boolean allFilesDeleted = true;

        boolean deletePhysically = Turbine.getConfiguration()
        .getBoolean("scarab.attachment.remove.permanent",false);

        for (int i = 0; i < keys.length; i++)
        {
            String key = (String) keys[i];
            if (key.startsWith("file_delete_"))
            {
                String attachmentId = key.substring(12);
                Attachment attachment = AttachmentManager.getInstance(
                new NumberKey(attachmentId), false);
                MutableBoolean physicallyDeleted = new MutableBoolean(false);
                activitySet = issue.doRemoveAttachment(activitySet, physicallyDeleted, attachment,  user);
                //set deleted to false if at least for one of the
                //deleted attachmnents the file was not removed from
                //disk. 
                if (deletePhysically && !physicallyDeleted.booleanValue())
                {
                    allFilesDeleted = false;
                }
            }
        }

        if (activitySet != null)
        {
            if (allFilesDeleted)
            {
                scarabR.setConfirmMessage(DEFAULT_MSG);
            }
            else
            {
                scarabR.setAlertMessage(L10NKeySet.FilesPartiallyDeleted);
            }
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.ATTACHMENT_REMOVED, activitySet,
                    issue, user);
        }
        else
        {
            scarabR.setInfoMessage(L10NKeySet.NoFilesChanged);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSavedependencychanges(RunData data, TemplateContext context)
        throws Exception
    {
        saveDependencyChanges(data, context, false);
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSavenewdependencies(RunData data, TemplateContext context)
        throws Exception
    {
        saveNewDependencies(data, context, false);
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
private void saveDependencyChanges(RunData data, TemplateContext context, 
                                       boolean doDelete)
        throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        String modifyDepTo = data.getParameters().get("modifyDepTo");
        boolean changesMade = false;

        DependType newDependType = null;
        if(modifyDepTo == null || modifyDepTo.equals(""))
        {
            // no dependType set -> error
        }
        else if (modifyDepTo.equals("remove"))
        {
            changesMade = doRemoveSelectedDependencies(issue, intake, scarabR, 
                          context, l10n, user);
        }
        else
        {
            /* If modifyDepTo equals "-1" we want the current issue to become
             * a prerequisite for the other issue.
             */
            boolean setAsPrerequisite = false;
            if(modifyDepTo.equals("-1"))
            {
                modifyDepTo = modifyDepTo.substring(1);
                setAsPrerequisite = true;
            }

            newDependType = DependTypeManager.getInstanceById(modifyDepTo);
            changesMade = doUpdatedependencies(issue, intake, scarabR, 
                          context, user, newDependType, setAsPrerequisite);
        }        

        if (!changesMade)
        {
            scarabR.setInfoMessage(NO_CHANGES_MADE);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
private void saveNewDependencies(RunData data, TemplateContext context, 
                                       boolean doDelete)
        throws Exception
    {
        if (isCollision(data, context)) 
        {
            return;
        }

        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }

        ScarabUser user = (ScarabUser)data.getUser();
        if (!user.hasPermission(ScarabSecurity.ISSUE__EDIT, 
                               issue.getModule()))
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        Group group = intake.get("Depend","newDep"+issue.getQueryKey(),false);

        boolean depAdded = doAdddependency(issue, intake, group, scarabR,
                                           context, l10n, user);
        if (!depAdded)
        {
            scarabR.setAlertMessage(ERROR_MESSAGE);
            scarabR.setInfoMessage(NO_CHANGES_MADE);
        }
        else
        {
            intake.remove(group);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
private boolean doAdddependency(Issue issue, IntakeTool intake,
                                 Group group, ScarabRequestTool scarabR,
                                 TemplateContext context,
                                 ScarabLocalizationTool l10n,
                                 ScarabUser user)
        throws Exception
    {
        // Check that dependency type entered is valid
        Field type = group.get("TypeId");
        Integer typeAsInteger = null;
        try
        {
            typeAsInteger = (Integer)type.getValue();
        }
        catch (Exception e)
        {
            type.setMessage(l10n.get(L10NKeySet.SelectRelation));
            return false;
        }
        boolean needRoleSwitch = false;
        if(typeAsInteger.intValue() < 1)
        {
            typeAsInteger = new Integer( -1 * typeAsInteger.intValue());
            needRoleSwitch = true;
        }

        type.setRequired(true);
        // Check that child ID entered is valid
        Field childId = group.get("ObserverUniqueId");
        childId.setRequired(true);
        if (!type.isValid() && childId.isValid())
        {
            type.setMessage(l10n.get(L10NKeySet.EnterValidDependencyType));
            return false;
        }
        else if (type.isValid() && !childId.isValid())
        {
            childId.setMessage(l10n.get(L10NKeySet.EnterValidIssueId));
            return false;
        }
        String childIdStr = childId.toString();
        // we need to struggle here because if there is no
        // issue id, we just want to return because the person
        // on the page could just be updating existing deps
        // and in this case, the issue id might be empty.
        if (childIdStr != null)
        {
            childIdStr.trim();
        }
        if (childIdStr == null || childIdStr.length() == 0)
        {
            return true;
        }
        // Check that child ID entered corresponds to a valid issue
        // The id might not have the prefix appended so use the current
        // module prefix as the thing to try.
        Issue childIssue = null;
        Module currentModule = scarabR.getCurrentModule();
        try
        {
            childIssue = IssueManager
                .getIssueById(childIdStr, currentModule.getCode());
        }
        catch(Exception e)
        {
            // Ignore this
        }
        if (childIssue == null || childIssue.getDeleted())
        {
            childId.setMessage(l10n.get(L10NKeySet.EnterValidIssueId));
            return false;
        }
        

        
        // Make sure issue is not being marked as dependant on itself.
        else if (childIssue.equals(issue))
        {
            childId.setMessage(l10n.get(L10NKeySet.CannotAddSelfDependency));
            return false;
        }
        if (intake.isAllValid())
        {
            Depend depend = DependManager.getInstance();
            depend.setDefaultModule(currentModule);
            group.setProperties(depend);
            depend.setTypeId(typeAsInteger);
            ActivitySet activitySet = null;
            try
            {
                if (needRoleSwitch)
                {
                    depend.exchangeRoles();
                    activitySet = issue
                    .doAddDependency(activitySet, depend, childIssue, user);
                }
                else{
                    activitySet = childIssue
                    .doAddDependency(activitySet, depend, issue, user);
                }

            }
            catch (ScarabException se)
            {
                childId.setMessage(se.getL10nMessage().getMessage(l10n));
                return false;
            }
            catch (Exception e)
            {
                log().debug("Delete error: ", e);
                return false;
            }

            scarabR.setConfirmMessage(DEFAULT_MSG);
            if (activitySet != null)
            {
                // FIXME: I think that we are sending too many emails here
                NotificationManagerFactory.getInstance()
                        .addActivityNotification(
                                ActivityType.DEPENDENCY_CREATED,
                                activitySet, childIssue, user);
                NotificationManagerFactory.getInstance()
                        .addActivityNotification(
                                ActivityType.DEPENDENCY_CREATED,
                                activitySet, issue, user);
            }
            return true;
        }
        else
        {
            return false;
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
private boolean doUpdatedependencies(Issue issue, IntakeTool intake, 
                                       ScarabRequestTool scarabR,
                                       TemplateContext context,
                                       ScarabUser user,
                                       DependType newDependType,
                                       boolean setAsPrerequisite)
        throws Exception
    {

        ActivitySet activitySet = null;
        List dependencies = issue.getAllDependencies();

        for (int i=0; i < dependencies.size(); i++)
        {
            Issue workingIssue = issue;
            Depend oldDepend = (Depend)dependencies.get(i);
            DependType oldDependType = oldDepend.getDependType();
            String intakeKey = oldDepend.getObserverId().toString();
            boolean thisIsPrerequisite = true;
            Group group = intake.get("Depend", intakeKey, false);
            if (group == null)
            {
                thisIsPrerequisite = false;
                intakeKey = oldDepend.getObservedId().toString();
                group = intake.get("Depend", intakeKey, false);
                if (group == null)
                {
                    // there is nothing to do here.
                    continue;
                }
                workingIssue = IssueManager.getInstance(oldDepend.getObservedId(), false);
            }

            Depend newDepend = DependManager.getInstance();
            // copy oldDepend properties to newDepend
            newDepend.setProperties(oldDepend);


            // set properties on the object
            group.setProperties(newDepend);

            boolean isSelected = newDepend.getSelected();
            boolean dependTypeModified = !oldDependType.equals(newDependType);
            boolean needRoleSwitch = newDependType.getName().equals("blocking") && setAsPrerequisite!=thisIsPrerequisite;
            if (isSelected && (dependTypeModified || needRoleSwitch ))
            {
                // need to do this because newDepend could have the deleted
                // flag set to true if someone selected it as well as 
                // clicked the save changes button. this is why we have the 
                // doDeleted flag as well...issue.doChange will only do the
                // change if the deleted flag is false...so force it...
                newDepend.setDeleted(false);
                newDepend.setDependType(newDependType);

                if(needRoleSwitch)
                {
                    newDepend.exchangeRoles();
                }
                
                 // make the changes
                  activitySet = 
                  workingIssue.doChangeDependencyType(activitySet, oldDepend,
                                                      newDepend, user);
            }
            intake.remove(group);
        }

        // something changed...
        if (activitySet != null)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.DEPENDENCY_CHANGED,
                    activitySet, issue, user);
            return true;
        }
        else // nothing changed
        {
            return false;
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
private boolean doRemoveSelectedDependencies(Issue issue, IntakeTool intake, 
                                       ScarabRequestTool scarabR,
                                       TemplateContext context,
                                       ScarabLocalizationTool l10n,
                                       ScarabUser user)
        throws Exception
    {

        ActivitySet activitySet = null;
        List dependencies = issue.getAllDependencies();

        for (int i=0; i < dependencies.size(); i++)
        {
            Depend oldDepend = (Depend)dependencies.get(i);
            
            // Assume, issue takes the role "observer"
            String intakeKey = oldDepend.getObserverId().toString();
            Group group = intake.get("Depend", intakeKey, false);
            Issue workingIssue = issue;

            if (group == null)
            {
                // Maybe issue takes the role "observed"
                intakeKey = oldDepend.getObservedId().toString();
                group = intake.get("Depend", intakeKey, false);
                if(group == null)
                {
                    // there is nothing to do here.
                    continue;
                }
                workingIssue = oldDepend.getIssueRelatedByObservedId();
            }

            group.setProperties(oldDepend);
            if (oldDepend.getSelected())
            {
                try
                {
                    activitySet = 
                        workingIssue.doDeleteDependency(activitySet, oldDepend, user);
                }
                catch (ScarabException se)
                {
                    // it will error out if they attempt to delete
                    // a dep via a child dep.
                    String l10nKey = se.getMessage();
                    scarabR.setAlertMessage(l10n.get(l10nKey));
                }
                catch (Exception e)
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    log().debug("Delete error: ", e);
                }
            }
            intake.remove(group);
        }

        // something changed...
        if (activitySet != null)
        {
            scarabR.setConfirmMessage(DEFAULT_MSG);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.DEPENDENCY_CHANGED,
                    activitySet, issue, user);
            
            return true;
        }
        else // nothing changed
        {
            return false;
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doEditassignees(RunData data, TemplateContext context)
         throws Exception
    {
        IntakeTool intake = getIntakeTool(context);
        intake.removeAll();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Issue issue = scarabR.getIssue();
        if (issue == null)
        {
            // no need to set the message here as
            // it is done in scarabR.getIssue()
            return;
        }
        ScarabUser user = (ScarabUser)data.getUser();
        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                               issue.getModule()))
        {
            data.getParameters().add("id", issue.getUniqueId());
            data.getParameters().add("issue_ids", issue.getUniqueId());
            scarabR.resetAssociatedUsers();
            setTarget(data, "AssignIssue.vm");
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doMove(RunData data, TemplateContext context)
         throws Exception
    {
        boolean collisionOccurred = isCollision(data, context);
        context.put("collisionDetectedOnMoveAttempt", collisionOccurred ? Boolean.TRUE : Boolean.FALSE);
        if (collisionOccurred)
        {
            // Report the collision to the user.
            return;
        }
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Module module = scarabR.getCurrentModule();
        List moveToModules =((ScarabUser)data.getUser()).getCopyToModules(module, "move");
        if (moveToModules.size() > 0)
        {
            ParameterParser pp = data.getParameters();
            pp.setString("mv_0rb", "move");
            ((IntakeTool)context.get("intake")).get("MoveIssue")
                .getDefault().get("Action").init(pp);
            String[] issueIds = pp.getStrings("issue_ids");
            String currentIssueId = getScarabRequestTool(context).getIssue().getUniqueId();
            if (!ScarabUtil.contains(issueIds, currentIssueId))
            {
                pp.add("issue_ids", currentIssueId);
            }
            setTarget(data, "MoveIssue.vm");
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
            setTarget(data, "ViewIssue.vm");
        }
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doCopy(RunData data, TemplateContext context)
         throws Exception
    {
        boolean collisionOccurred = isCollision(data, context);
        context.put("collisionDetectedOnMoveAttempt", collisionOccurred ? Boolean.TRUE : Boolean.FALSE);
        if (collisionOccurred)
        {
            // Report the collision to the user.
            return;
        }
        ParameterParser pp = data.getParameters();
        pp.setString("mv_0rb", "copy");
        ((IntakeTool)context.get("intake")).get("MoveIssue")
            .getDefault().get("Action").init(pp);
        String[] issueIds = pp.getStrings("issue_ids");
        String currentIssueId = getScarabRequestTool(context).getIssue().getUniqueId();
        if (!ScarabUtil.contains(issueIds, currentIssueId))
        {
            pp.add("issue_ids", currentIssueId);
        }
        setTarget(data, "MoveIssue.vm");            
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doSetissueview(RunData data, TemplateContext context)
         throws Exception
    {
        String tab = data.getParameters().getString("tab", 
                                          ScarabConstants.ISSUE_VIEW_ALL);
        data.getUser().setTemp(ScarabConstants.TAB_KEY, tab); 
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doAddmyself(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);
        
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssue();
        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, 
                               issue.getModule()))
        {
            // We'll set the info required by AssignIssue.doAddmyself (the)
            // same that in doEditassignees in this same class.
            data.getParameters().add("id", issue.getUniqueId());
            data.getParameters().add("issue_ids", issue.getUniqueId());

            scarabR.resetAssociatedUsers();
            
            // Lets cross-call the AssignIssue Turbine action!
            AssignIssue assignAction = new AssignIssue();
            assignAction.doAddmyself(data, context);
            assignAction.doDone(data, context);
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }        
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doDeleteissue(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);
        ScarabUser user = (ScarabUser)data.getUser();
        Issue issue = scarabR.getIssue();
        if (user != null && issue != null)
        {
           issue.deleteIssue(user);
        }
        L10NMessage msg = new L10NMessage(L10NKeySet.IssueDeleted, issue.getUniqueId());
        scarabR.setInfoMessage(msg);
    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
public void doRemovemyself(RunData data, TemplateContext context)
    throws Exception
    {
        ScarabRequestTool scarabR = this.getScarabRequestTool(context);

        ScarabUser user = (ScarabUser) data.getUser();
        Issue issue = scarabR.getIssue();
        if (user.hasPermission(ScarabSecurity.ISSUE__ASSIGN, issue.getModule()))
        {
            // We'll set the info required by AssignIssue.doRemovemyself (the)
            // same that in doEditassignees in this same class.
            data.getParameters().add("id", issue.getUniqueId());
            data.getParameters().add("issue_ids", issue.getUniqueId());

            scarabR.resetAssociatedUsers();

            // Lets cross-call the AssignIssue Turbine action!
            AssignIssue assignAction = new AssignIssue();
            assignAction.doRemovemyself(data, context);
            assignAction.doDone(data, context);
        }
        else
        {
            scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
        }
    }
            
// in java/org/tigris/scarab/actions/ChangePassword.java
public void doChangepassword(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String template = getCurrentTemplate(data, null);
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid())
        {
            Object user = data
                .getUser()
                .getTemp(ScarabConstants.SESSION_REGISTER);
            Group register = null;
            if (user != null && user instanceof ScarabUser)
            {
                register = intake.get("Register",
                                 ((ScarabUser)user).getQueryKey(), false);
            }
            else
            {
                register = intake.get("Register",
                                 IntakeTool.DEFAULT_KEY, false);
            }
            
            String username = data.getParameters().getString("username");
            String oldPassword = register.get("OldPassword").toString();
            String password = register.get("Password").toString();
            String passwordConfirm = register.get("PasswordConfirm").toString();
            
            if (oldPassword.equals(password))
            {
                scarabR.setInfoMessage(L10NKeySet.PasswordSame);
                setTarget(data, template);
            } 
            else if (password.equals(passwordConfirm))
            {
                try
                {
                    ScarabUser confirmedUser = ScarabUserManager.getInstance(username);

                    // first we need to save the user out
                    confirmedUser.setPasswordExpire();
                    confirmedUser.setHasLoggedIn(Boolean.FALSE);
                    data.setUser(confirmedUser);
                    data.save();

                    // then change the password of that user
                    TurbineSecurity.changePassword(confirmedUser, 
                        oldPassword, password);

                    scarabR.setConfirmMessage(L10NKeySet.PasswordChanged);
                    
                    // Remove NEXT_TEMPLATE, so we will start again from home after login
                    data.getParameters().remove(ScarabConstants.NEXT_TEMPLATE);
                    setTarget(data, "Login.vm");
                }
                catch (PasswordMismatchException pme)
                {
                    scarabR.setAlertMessage(l10n.getMessage(pme));
                    setTarget(data, template);
                }
            }
            else /* !password.equals(passwordConfirm) */
            {
                scarabR.setAlertMessage(L10NKeySet.PasswordsDoNotMatch);
                setTarget(data, template);
            }
        }
        else
        {
            scarabR.setAlertMessage("Failed to process form input.");
            setTarget(data, template);
        }
    }
            
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
public void doSave(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);

        // Add user's new selection of attributes
        ParameterParser params = data.getParameters();
        String[] ids = params.getStrings("attid");
        String[] orders = params.getStrings("attorder");
        MITList mitlist = ((ScarabUser)data.getUser()).getCurrentMITList();
        boolean isSingleModuleIssueType = mitlist.isSingleModuleIssueType();

        if (ids != null)
        {
	        List attributes = new ArrayList(ids.length);
	        final Map orderMap = new HashMap();            
	        for (int i =0; i<ids.length; i++)
	        {
                RModuleUserAttribute pref = RModuleUserAttributeManager.getInstance();
                pref.setUserId(((ScarabUser)data.getUser()).getUserId());
	            if (!orders[i].equals("hidden")) 
	            {
                    Integer order = new Integer(orders[i]);
                    try
                    {
    	                Attribute attribute = AttributeManager
    	                    .getInstance(new Integer(ids[i]));
                        if (isSingleModuleIssueType)
                        {
                            //String value = mitlist.getModule().getRModuleAttribute(attribute, mitlist.getIssueType()).getDisplayValue();
                            pref.setAttribute(attribute);
                            pref.setIssueType(mitlist.getIssueType());
                        }
                        else
                        {
                            pref.setMITList(mitlist);
                            pref.setAttribute(attribute);
                        }
                        orderMap.put(pref.getAttributeId(), order);
                    }
                    catch (NumberFormatException nfe)
                    {
                        pref.setInternalAttribute(ids[i]);
                        orderMap.put(pref.getInternalAttribute(), order);
                    }
                    attributes.add(pref);
	            }
	        }
	
	        if (attributes.isEmpty())
	        {
	            scarabR.setAlertMessage(L10NKeySet.MustSelectAtLeastOneAttribute);
	            setTarget(data, data.getParameters()
	                            .getString(ScarabConstants.TEMPLATE, 
	                                       "ConfigureIssueList.vm"));
	            return;
	        }
	        else if (((ScarabUser)data.getUser()).getCurrentMITList() == null) 
	        {
	            scarabR.setAlertMessage(L10NKeySet.NoIssueTypeList);
	            return;            
	        }
	        else
	        {
	            Comparator c = new Comparator()
	                {
	                    public int compare(Object o1, Object o2)
	                    {
                            RModuleUserAttribute a1 = (RModuleUserAttribute)o1;
                            RModuleUserAttribute a2 = (RModuleUserAttribute)o2;
	                        int order1, order2;
                            if (a1.isInternal())
                            {
                                order1 = ((Integer)orderMap.get(a1.getInternalAttribute())).intValue();
                            }
                            else
                            {
                                order1 = ((Integer)orderMap.get(a1.getAttributeId())).intValue();
                            }
                            if (a2.isInternal())
                            {
                                order2 = ((Integer)orderMap.get(a2.getInternalAttribute())).intValue();
                            }
                            else
                            {
                                order2 = ((Integer)orderMap.get(a2.getAttributeId())).intValue();
                            }
                            
                            int result = order1 - order2;
	                        if (result == 0) 
	                        {
	                            result = a1.getName().compareTo(a2.getName());
	                        }
	                        return result;
	                    }
	                };
	            Collections.sort(attributes, c);
                context.put("attributepreferences", attributes);
                scarabR.setConfirmMessage(DEFAULT_MSG);
	            try
	            {
	                ((ScarabUser)data.getUser()).updateIssueListAttributes(attributes);
//  	                scarabR.setConfirmMessage(DEFAULT_MSG);
	            }
	            catch (TurbineSecurityException tse)
	            {
	                scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
	            }
	        }
        }
        
        scarabR.clearCachedQueryResult();
        
        doCancel(data,context);
    }
            
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
public void doUsedefaults(RunData data, TemplateContext context) 
        throws Exception
    {
        data.getParameters().add("usedefaults", "true"); 
    }
            
// in java/org/tigris/scarab/actions/Login.java
public void doLogin(RunData data, TemplateContext context)
        throws Exception
    {
        data.setACL(null);
        IntakeTool intake = getIntakeTool(context);
        if (intake.isAllValid() && checkUser(data, context))
        {
            ScarabUser user = (ScarabUser)data.getUser();
            List userModules = user.getModules();
            if (userModules != null)
            {
                Module uniqueModule = null;
                if (userModules.size() == 2)
                {
                    Module module1 = (Module)userModules.get(0);
                    Module module2 = (Module)userModules.get(1);
                    if (module1.isGlobalModule())
                    {
                        uniqueModule = module2;
                    }
                    else if (module2.isGlobalModule())
                    {
                        uniqueModule = module1;
                    }
                }
                else if (userModules.size() == 1)
                {
                    uniqueModule = (Module)userModules.get(0);
                    if (uniqueModule.isGlobalModule())
                    {
                        uniqueModule = null;
                    }
                }

                if (uniqueModule != null )
                {
                    getScarabRequestTool(context).setCurrentModule(uniqueModule);
                    data.getParameters().remove(ScarabConstants.CURRENT_MODULE);
                    data.getParameters().add(ScarabConstants.CURRENT_MODULE,
                                             uniqueModule.getQueryKey());

                    if ("SelectModule.vm".equals(data.getParameters()
                            .getString(ScarabConstants.NEXT_TEMPLATE, "SelectModule.vm"))
                        && user.hasPermission(ScarabSecurity.ISSUE__ENTER, uniqueModule )) 
                    {
                        data.getParameters().remove(ScarabConstants.NEXT_TEMPLATE);
                        
                        Query defaultQuery = QueryPeer.getDefaultQuery(uniqueModule, user.getUserId());
                        ParameterParser pp = data.getParameters();
                        if(defaultQuery != null)
                        {
                            String qkey = defaultQuery.getQueryKey();
                            pp.add(ScarabConstants.NEXT_TEMPLATE, "IssueList.vm");
                            //pp.add("queryId", qkey);
                            //pp.add("query", qkey);
                            //data.setAction("Search");
                            pp.setString("eventSubmit_doSelectquery", "foo");
                            pp.setString("go",qkey);
                            Search action = new Search();
                            action.doSelectquery(data, context);
                            
                            MITList mitList = defaultQuery.getMITList();
                            user.setCurrentMITList(mitList);
                            String mitListId = Long.toString(mitList.getListId());
                            pp.setString(ScarabConstants.CURRENT_MITLIST_ID, mitListId);
                        }
                        else
                        {
                            pp.add(ScarabConstants.NEXT_TEMPLATE, "home,EnterNew.vm");
                        }
                    }
                }
            }
            String template = data.getParameters()
                .getString(ScarabConstants.NEXT_TEMPLATE, 
                           "SelectModule.vm");
            setTarget(data, template);
        }
    }
            
// in java/org/tigris/scarab/actions/Login.java
public boolean checkUser(RunData data, TemplateContext context)
        throws Exception
    {
        IntakeTool intake = getIntakeTool(context);

        Group login = intake.get("Login", IntakeTool.DEFAULT_KEY);
        String username = login.get("Username").toString();
        String password = login.get("Password").toString();
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        
        return authentifyWithCredentials(data, scarabR, username, password);
    }
            
// in java/org/tigris/scarab/actions/Login.java
public static boolean authentifyWithCredentials(RunData data, ScarabRequestTool scarabR, String username, String password) throws Exception
    {
        
        ScarabUser user = authenticateUser(data, scarabR, username, password);
        if(user == null)
        {
            // Could not authenticate the user
            return false;
        }

        try
        {
            if (user.getConfirmed().equals(ScarabUser.DELETED))
            {
                setAlertMessage(scarabR,L10NKeySet.UserIsDeleted);
                Log.get().error("Deleted user attempting to log in");
                failAction(data, "Login.vm");
                return false;
            }
            // check the CONFIRM_VALUE
            if (!user.isConfirmed())
            {
                user = (ScarabUser) TurbineSecurity.getUserInstance();
                setUser(scarabR, user);
                setAlertMessage(scarabR,L10NKeySet.UserIsNotConfirmed);

                failAction(data, "Confirm.vm");
                return false;
            }


            // store the user object
            data.setUser(user);
            // mark the user as being logged in
            user.setHasLoggedIn(Boolean.TRUE);
            // set the last_login date in the database
            user.updateLastLogin();

            // check if the password is expired
            boolean userPasswordExpired = user.isPasswordExpired();
            if (userPasswordExpired)
            {
                user = (ScarabUser) TurbineSecurity.getUserInstance();
                setUser(scarabR, user);
                setAlertMessage(scarabR,L10NKeySet.YourPasswordHasExpired);

                setTarget(data, "ChangePassword.vm");
                //change next screen to allow password reset.
                data.save();
                return false;
            }

            // update the password expire
            user.setPasswordExpire();
            // this only happens if the user is valid
            // otherwise, we will get a valueBound in the User
            // object when we don't want to because the username is
            // not set yet.
                       
            // save the User object into the session
            data.save();

        }
        catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionTurbineGeneric,e);
            setAlertMessage(scarabR,msg);
            failAction(data, "Login.vm");
            return false;
        }
        return true;
    }
            
// in java/org/tigris/scarab/actions/Login.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doLogin(data, context);
    }
            
// in java/org/tigris/scarab/actions/Logout.java
public void doLogout(RunData data, TemplateContext context)
        throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        boolean bWasLoggedIn = data.getUserFromSession() != null && !((ScarabUser)data.getUserFromSession()).isUserAnonymous();
        scarabR.setCurrentModule(null);
        data.getParameters().remove(ScarabConstants.CURRENT_MODULE);
        data.setACL(null);
        Login.anonymousLogin(data);
        context.put("modulelink", new ModuleSwitchingLink(data));
        
        if(data.getUser()!=null)
        {
            data.save();
            if (bWasLoggedIn)
            {
                scarabR.setConfirmMessage(L10NKeySet.YouHaveBeenLoggedOut);
            }
        }
        setTarget(data, "Login.vm");
    }
            
// in java/org/tigris/scarab/actions/Logout.java
public void doPerform(RunData data, TemplateContext context)
        throws Exception
    {
        doLogout(data, context);
    }
            
// in java/org/tigris/scarab/actions/MoveIssue.java
public void doValidate(RunData data, TemplateContext context)
        throws Exception
    {
        boolean collisionOccurred = isCollision(data, context);
        context.put("collisionDetectedOnMoveAttempt",
                    collisionOccurred ? Boolean.TRUE : Boolean.FALSE);
        if (collisionOccurred)
        {
            // Report the collision to the user.
            doCancel(data, context);
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        if (!intake.isAllValid())
        {
            return;
        }

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        String[] issueIds = data.getParameters().getStrings("issue_ids");
        List issues = new ArrayList();
        Issue issue = null;
        if (issueIds == null || issueIds.length == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectIssueToMove);
            return;
        }
        else
        {
            for (int i= 0; i<issueIds.length; i++)
            {
                issues.add(scarabR.getIssue(issueIds[i]));
            }
            issue = (Issue)issues.get(0);
        }

        Module oldModule = issue.getModule();
        Group moveIssue = intake.get("MoveIssue",
                          IntakeTool.DEFAULT_KEY, false);
        String[] modIssueTypes =
            data.getParameters().getStrings("mod_issuetype");
        String modIssueType = null;
        if (modIssueTypes != null)
        {
            for (int i=0; i<modIssueTypes.length; i++) 
            {
                String testOption = modIssueTypes[i];
                if (testOption != null && testOption.length() > 0) 
                {
                    if (modIssueType == null) 
                    {
                        modIssueType = testOption;
                    }
                    else 
                    {
                        scarabR.setAlertMessage(L10NKeySet.OnlySelectOneDestination);
                        return;
                    }
                }
            }

        }

        if (modIssueType == null)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectModuleAndIssueType);
            return;
        }
        
        Integer newModuleId = null;
        Integer newIssueTypeId = null;
        Module newModule = null;        
        try
        {
            newModuleId = new Integer(modIssueType.
                      substring(0, modIssueType.indexOf('_')));
            newIssueTypeId = new Integer(modIssueType.
                      substring(modIssueType.indexOf('_')+1, modIssueType.length()));
            newModule = ModuleManager
                               .getInstance(newModuleId);

        }
        catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectModuleAndIssueType);
            return;
        }
          
        String selectAction = moveIssue.get("Action").toString();
        ScarabUser user = (ScarabUser)data.getUser();
        boolean changeModule = !newModuleId.equals(oldModule.getModuleId());
        boolean changeIssueType = !newIssueTypeId
            .equals(issue.getIssueType().getIssueTypeId());

        // Check permissions
        // Must have ISSUE_ENTER in new module
        // If moving to a new module, must have ISSUE_MOVE in old module
        // If moving to a new issue type, must have ISSUE_EDIT in old module
        if (!user.hasPermission(ScarabSecurity.ISSUE__ENTER, newModule))
        {
            data.setMessage(l10n.get(NO_PERMISSION_MESSAGE));
            return;
        }
        if ("move".equals(selectAction))
        {
            if (changeModule && 
                !user.hasPermission(ScarabSecurity.ISSUE__MOVE, oldModule) || 
                (changeIssueType && 
                !user.hasPermission(ScarabSecurity.ISSUE__EDIT, oldModule)))
            {
                data.setMessage(l10n.get(NO_PERMISSION_MESSAGE));
                return;
            }
        }
        // Do not allow user to move issue if source and destination
        // Module and issue type are the same
        if ("move".equals(selectAction) && !changeModule && !changeIssueType)
        {
            scarabR.setAlertMessage(L10NKeySet.CannotMoveToSameModule);
            return;
        }
       
        context.put("newModuleId", newModuleId.toString());
        context.put("newIssueTypeId", newIssueTypeId.toString());
        String nextTemplate = getNextTemplate(data);
        setTarget(data, nextTemplate);
    }
            
// in java/org/tigris/scarab/actions/MoveIssue.java
public void doSaveissue(RunData data, TemplateContext context)
        throws Exception
    {
    	//Clear cache for stability reasons, to avoid missing, cached values
    	IssueManager.getMethodResult().clear();
    	
        boolean collisionOccurred = isCollision(data, context);
        context.put("collisionDetectedOnMoveAttempt", collisionOccurred ? Boolean.TRUE : Boolean.FALSE);
        if (collisionOccurred)
        {
            // Report the collision to the user.
            setTarget(data, "ViewIssue.vm");
            return;
        }

        IntakeTool intake = getIntakeTool(context);
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        if (!intake.isAllValid())
        {
            return;
        }

        ScarabLocalizationTool l10n = getLocalizationTool(context);
        String[] issueIds = data.getParameters().getStrings("issue_ids");
        List issues = new ArrayList();
        Issue issue = null;
        if (issueIds == null || issueIds.length == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectIssueToMove);
            return;
        }
        else
        {
            for (int i= 0; i<issueIds.length; i++)
            {
                issues.add(scarabR.getIssue(issueIds[i]));
            }
            issue = (Issue)issues.get(0);
        }

        Module oldModule = issue.getModule();
        IssueType oldIssueType = issue.getIssueType();
        Group moveIssue = intake.get("MoveIssue",
                          IntakeTool.DEFAULT_KEY, false);
        Integer newModuleId = ((Integer) moveIssue.get("ModuleId").
            getValue());
        Integer newIssueTypeId = ((Integer) moveIssue.get("IssueTypeId").
            getValue());
        Module newModule = ModuleManager
               .getInstance(newModuleId);
        IssueType newIssueType = IssueTypeManager
               .getInstance(newIssueTypeId);
        String selectAction = moveIssue.get("Action").toString();
        ScarabUser user = (ScarabUser)data.getUser();

        ActivityType activityType = null;
        if (selectAction.equals("move"))
            activityType = ActivityType.ISSUE_MOVED;
        else
            activityType = ActivityType.ISSUE_COPIED;
        
        // Get selected non-matching attributes to save in comment
        List commentAttrs = new ArrayList();
        List commentUserValues = new ArrayList();
        ParameterParser params = data.getParameters();
        Object[] keys = params.getKeys();
        for (int i=0; i<keys.length; i++)
        {
            String key = (String) keys[i];
            if (key.startsWith("comment_attr_ids_"))
            {
                commentAttrs.add(scarabR 
                        .getAttribute(new Integer(key.substring(17))));
            }
            if (key.startsWith("comment_user_attval_"))
            {
                Long valueId = new Long(key.substring(20));
                commentUserValues.add(AttributeValuePeer.retrieveByPK(valueId));
            }
        }
        String reason = params.getString("reason");
        if (reason == null || reason.trim().length() == 0)
        {
            scarabR.setAlertMessage(L10NKeySet.ReasonRequired);
            return;
        }

        Issue newIssue = null;
        for (int i=0; i<issues.size(); i++)
        {
            issue = (Issue)issues.get(i);
            // Do the copy/move
            try
            {
            	if("move".equals(selectAction)){
            		 newIssue = issue.move(newModule, newIssueType, user,
                             reason, commentAttrs, commentUserValues);
            	}
            	else if("copy".equals(selectAction)){
            		 newIssue = issue.copy(newModule, newIssueType, user,
                             reason, commentAttrs, commentUserValues);
            	}
               
            }
            catch (Exception e)
            {
                L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
                scarabR.setAlertMessage(l10nMessage);
                Log.get().warn("Exception during issue copy/move", e);
                return;
            }

            // Send notification for the target issue/module
            NotificationManagerFactory.getInstance().addActivityNotification(
                    activityType,
                    newIssue.getLastActivitySet(), issue, null, null, user);

            // If it's moved, should also notify users associated in the old
            // location because the issue is dissapearing from there.
            if (activityType == ActivityType.ISSUE_MOVED)
            {
                NotificationManagerFactory
                        .getInstance()
                        .addActivityNotification(
                                activityType,
                                issue.getLastActivitySet(), issue, null,
                                null, user);
            }
        }

        // Redirect to moved or copied issue
        if (issues.size() == 1)
        {
            data.getParameters().remove("id");
            data.getParameters().add("id", newIssue.getUniqueId().toString());
            setTarget(data, "ViewIssue.vm");
        }
        else
        {
            setTarget(data, "IssueList.vm");
        }

        scarabR.setConfirmMessage(DEFAULT_MSG);
    }
            
// in java/org/tigris/scarab/actions/MoveIssue.java
public void doBacktoone(RunData data, TemplateContext context) throws Exception
    {
        setTarget(data, data.getParameters()
            .getString(ScarabConstants.CANCEL_TEMPLATE, "MoveIssue.vm"));
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public ScarabUser getGeneratedBy() 
        throws Exception
    {
        if (generatedBy == null) 
        {
            if (torqueReport.getUserId() != null) 
            {
                generatedBy = 
                    ScarabUserManager.getInstance(torqueReport.getUserId());
            }
        }
        
        return generatedBy;
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setGeneratedBy(ScarabUser  v)
        throws Exception
    {
        this.generatedBy = v;
        torqueReport.setUserId(v.getUserId());
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setMITList(MITList mitList)
        throws Exception
    {
        if (mitList == null) 
        {
            reportDefn.setModuleIssueTypes(null);
            setModule(null);
            setIssueType(null);
        }
        else 
        {
            boolean isOk = true;
            // need to check that the changes are compatible with the currently
            // selected criteria
            for (Iterator roai = reportDefn
                .retrieveAllReportOptionAttributes().iterator(); 
                 roai.hasNext() && isOk;) 
            {
                isOk = mitList.isCommon( AttributeOptionManager.getInstance( 
                    ((ReportOptionAttribute)roai.next())
                    .getOptionId()));
            }
            for (Iterator ruai = reportDefn
                .retrieveAllReportUserAttributes().iterator(); 
                 ruai.hasNext() && isOk;) 
            {
                isOk = mitList.isCommon( AttributeManager.getInstance( 
                    ((ReportUserAttribute)ruai.next())
                    .getAttributeId()));
            }
            
            if (!isOk) 
            {
                throw new IncompatibleMITListException(L10NKeySet.ExceptionIncompatibleMITListChanges); //EXCEPTION
            }
            
            reportDefn.setModuleIssueTypes(null);
            setModule(null);
            setIssueType(null);

            for (Iterator i = mitList.getExpandedMITListItems().iterator(); i.hasNext();) 
            {
                MITListItem item = (MITListItem)i.next();
                ModuleIssueType mit = new ModuleIssueType();
                mit.setModuleId(item.getModuleId());
                mit.setIssueTypeId(item.getIssueTypeId());
                reportDefn.addModuleIssueType(mit);
            }
            if (mitList.isSingleModule()) 
            {
                torqueReport.setModule(mitList.getModule());
            }
            if (mitList.isSingleIssueType()) 
            {
                torqueReport.setIssueType(mitList.getIssueType());
            }
        }
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public boolean removeStaleDefinitions()
        throws Exception
    {
        boolean reportModified = false;
        MITList mitList = getMITList();
        List axes = reportDefn.getReportAxisList();
        if (axes != null) 
        {
            for (Iterator i = axes.iterator(); i.hasNext();) 
            {
                ReportAxis axis = (ReportAxis)i.next();
                List headings = axis.getReportHeadings();
                if (headings != null) 
                {
                    for (Iterator j = headings.iterator(); j.hasNext();) 
                    {
                        ReportHeading heading = (ReportHeading)j.next();
                        reportModified |= removeStaleOptions(
                            heading.getReportOptionAttributes(), mitList);
                        reportModified |= removeStaleUserAttributes(heading
                            .getReportUserAttributes(), mitList);
                        List groups = heading.getReportGroups();
                        if (groups != null && !groups.isEmpty()) 
                        {
                            for (Iterator n = groups.iterator(); n.hasNext();) 
                            {
                                ReportGroup group = (ReportGroup)n.next();
                                reportModified |= removeStaleOptions(
                                    group.getReportOptionAttributes(), mitList );
                                reportModified |= removeStaleUserAttributes( 
                                    group.getReportUserAttributes(), mitList );
                            }
                        }
                    }
                }
            }
        }
        return reportModified;
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
private boolean removeStaleOptions(List options, MITList mitList)
        throws Exception
    {
        boolean anyRemoved = false;
        if (options != null && !options.isEmpty()) 
        {
            for (Iterator n = options.iterator(); n.hasNext();)
            {
                ReportOptionAttribute rao = 
                    (ReportOptionAttribute)n.next();
                AttributeOption ao = AttributeOptionManager
                    .getInstance(rao.getOptionId());
                if (!mitList.isCommon(ao, false)) 
                {
                    n.remove();
                    anyRemoved = true;
                }
                else if (!mitList.isCommon(ao.getAttribute(), false)) 
                {
                    n.remove();
                    anyRemoved = true;
                }
            }
        }
        return anyRemoved;
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
private boolean removeStaleUserAttributes(List attributes, MITList mitList)
        throws Exception
    {
        boolean anyRemoved = false;
        if (attributes != null && !attributes.isEmpty()) 
        {
            for (Iterator n = attributes.iterator(); n.hasNext();)
            {
                ReportUserAttribute rua = 
                    (ReportUserAttribute)n.next();
                Attribute attr = AttributeManager
                    .getInstance(rua.getAttributeId());
                if (!mitList.isCommon(attr, false)) 
                {
                    n.remove();
                    anyRemoved = true;
                }
            }
        }
        return anyRemoved;
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public ReportTableModel getCachedModel(ScarabUser searcher)
        throws Exception
    {        
        ReportTableModel model=(ReportTableModel) ReportManager.getMethodResult().get(this,GET_CACHED_MODEL,searcher);

        if(model==null){
            generatedDate=new Date();
            model=new ReportTableModel(this, getGeneratedDate(), searcher);
        }

        ReportManager.getMethodResult().put(model,this,GET_CACHED_MODEL,searcher);

        return model;
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public ReportTableModel getModel(ScarabUser searcher) throws Exception
    {
        return new ReportTableModel(this, getGeneratedDate(), searcher);
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void save() 
        throws Exception
    {
        torqueReport.setQueryString(getQueryString());
        torqueReport.save();
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void populate(String v)
        throws Exception
    {
        if (v == null)
        {
            reportDefn = new ReportDefinition();
        }
        else
        {
            BeanReader reader = new BeanReader();
            reader.registerBeanClass(ReportDefinition.class);
            reportDefn = (ReportDefinition) 
                reader.parse(new StringReader(v));

            Logger log = Log.get();
            if (log.isDebugEnabled())
            {
                log.debug("Created a new report using:\n " + v + 
                          "; and it resulted in:\n " + 
                          reportDefn.toXmlString());
            }
        }
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
String getQueryString()
        throws Exception
    {
        return reportDefn.toXmlString();
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void populateSearch(IssueSearch search, ReportHeading heading)
        throws Exception
    {
        List reportOptions = heading.getReportOptionAttributes();
        if (reportOptions == null || reportOptions.isEmpty()) 
        {
            List groups = heading.getReportGroups();
            if (groups != null && !groups.isEmpty()) 
            {
                reportOptions = new ArrayList();
                for (Iterator i = groups.iterator(); i.hasNext();) 
                {
                    ReportGroup group = (ReportGroup)i.next();
                    List tmpOptions = group.getReportOptionAttributes();
                    if (tmpOptions != null && !tmpOptions.isEmpty()) 
                    {
                        for (Iterator j = tmpOptions.iterator(); j.hasNext();) 
                        {
                            reportOptions.add(j.next());
                        }
                    }
                }
            }
        }

        if (reportOptions != null && !reportOptions.isEmpty()) 
        {
            Map commonAttributeMap = new HashMap(reportOptions.size());
            for (Iterator i = reportOptions.iterator(); i.hasNext();) 
            {
                ReportOptionAttribute roa = (ReportOptionAttribute)i.next();
                Integer optionId = roa.getOptionId();
                AttributeOption ao = 
                    AttributeOptionManager.getInstance(optionId);

                Integer attId = AttributeOptionManager.getInstance(optionId).getAttributeId();
                Attribute attr = AttributeManager.getInstance(attId); 

                AttributeValue prevAV = 
                    (AttributeValue)commonAttributeMap.get(attId);

                if(prevAV!=null) 
                {
                	AttributeValue av = AttributeValue
                    .getNewInstance(attr, prevAV.getIssue());
                    av.setAttributeOption(ao);
                    prevAV.setChainedValue(av);
                }
                else 
                {
                	AttributeValue av = search.addAttributeValue(attr, ao);
                    commonAttributeMap.put(attId, av);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/reports/ReportTableModel.java
public Object getValueAt(int row, int column)
        throws Exception
    {
        if (row < 0 || row >= getRowCount())
        {
            throw new IndexOutOfBoundsException("Row index was " + row); //EXCEPTION
        }
        
        if (column < 0 || column >= getColumnCount()) 
        {
            throw new IndexOutOfBoundsException("Column index was " + column); //EXCEPTION
        }

        Object contents = ReportManager.getMethodResult().get(this,GET_VALUE_AT,new Integer(row),new Integer(column));

        if(contents==null){
        
            //could use a categories list to make this simpler
            if (columnHeadings != null && columnHeadings.size() == 1 && 
                    ((ReportHeading)columnHeadings.get(0)).get(0) instanceof ReportDate) 
            {
                Date date = ((ReportDate) ((ReportHeading) columnHeadings.get(0))
                             .get(column)).dateValue();
                if (date.getTime() <= System.currentTimeMillis())
                {
                    contents = new Integer(getIssueCount(getRowDataArray(row),
                                                         date));
                }
                else
                {
                    // Dates in the future are not applicable to reporting.
                    contents = "";
                }
            }
            else if (rowHeadings != null && rowHeadings.size() == 1 && 
                     ((ReportHeading)rowHeadings.get(0)).get(0) instanceof ReportDate)
            {
                Date date = ((ReportDate)((ReportHeading)rowHeadings.get(0))
                             .get(row)).dateValue();
                if (date.getTime() <= System.currentTimeMillis())
                {
                   contents = new Integer(getIssueCount(
                        getColumnDataArray(column), date));
                }
                else
                {
                   // Dates in the future are not applicable to reporting.
                   contents = "";
                }
            }
            else if (columnHeadings != null && columnHeadings.size() == 1 && 
                    ((ReportHeading)columnHeadings.get(0)).get(0) instanceof ReportDateRange) 
            {
            	Date minDate =((ReportDateRange)((ReportHeading)columnHeadings.get(0))
                        .get(column)).getMinDate(searcher.getLocale());
            	
            	Date maxDate = ((ReportDateRange)((ReportHeading)columnHeadings.get(0))
                        .get(column)).getMaxDate(searcher.getLocale());
            	
            	contents = new Integer(getIssueCountRange(
                        getRowDataArray(row), minDate, maxDate));
            	
            }
            else if (rowHeadings != null && rowHeadings.size() == 1 && 
                     ((ReportHeading)rowHeadings.get(0)).get(0) instanceof ReportDateRange)
            {
            	Date minDate = ((ReportDateRange)((ReportHeading)rowHeadings.get(0))
                        .get(row)).getMinDate(searcher.getLocale());
            	
            	Date maxDate = ((ReportDateRange)((ReportHeading)rowHeadings.get(0))
                        .get(row)).getMaxDate(searcher.getLocale());
            	
            	contents = new Integer(getIssueCountRange(
                        getColumnDataArray(column), minDate, maxDate));
            }
            else
            {
                contents = new Integer(getIssueCount(
                    getRowDataArray(row), getColumnDataArray(column), date)); 
            }

            ReportManager.getMethodResult().put(contents,this,GET_VALUE_AT,new Integer(row),new Integer(column));
        }

        return contents;
    }
            
// in java/org/tigris/scarab/reports/ReportTableModel.java
private int getIssueCount(Object[] rowData, Object[] columnData, Date date)
        throws Exception
    {
        Criteria crit = new Criteria();
        // select count(issue_id) from activity a1 a2 a3, activitySet t1 t2 t3
        crit.addSelectColumn("count(DISTINCT a0." + ACT_ISSUE_ID + ')');
        int rowLength = rowData.length;
        for (int i=0; i<rowLength; i++) 
        {
            addOptionOrGroup(i, rowData[i], null, date, crit);
            
        }
        for (int i=0; i<columnData.length; i++) 
        {
            addOptionOrGroup(i+rowLength, columnData[i], null, date, crit);
        }
        return getCountAndCleanUp(crit);
    }
            
// in java/org/tigris/scarab/reports/ReportTableModel.java
public int getIssueCount(Object[] dataArray, Date date)
        throws Exception
    {
        Criteria crit = new Criteria();
        crit.addSelectColumn("count(DISTINCT a0." + ACT_ISSUE_ID + ')');
        for (int i=0; i<dataArray.length; i++) 
        {
            addOptionOrGroup(i, dataArray[i], null, date, crit);
        }
        return getCountAndCleanUp(crit);
    }
            
// in java/org/tigris/scarab/reports/ReportTableModel.java
public int getIssueCountRange(Object[] dataArray, Date minDate, Date maxDate)
    throws Exception
    {
    	Criteria crit = new Criteria();
    	crit.addSelectColumn("count(DISTINCT a0." + ACT_ISSUE_ID + ')');
    	for (int i=0; i<dataArray.length; i++) 
    	{
    		addOptionOrGroup(i, dataArray[i], minDate, maxDate, crit);
    	}
    	return getCountAndCleanUp(crit);
    }
            
// in java/org/tigris/scarab/reports/ReportTableModel.java
private int getCountAndCleanUp(Criteria crit)
        throws Exception
    {
        int result = 0;
        if (isSearchAllowed) 
        {
            if (isXMITSearch())
            {
                mitList.addToCriteria(crit);
            }
            else 
            {
                crit.add(IssuePeer.MODULE_ID, moduleId);
                crit.add(IssuePeer.TYPE_ID, issueTypeId);
            }
            crit.add(IssuePeer.DELETED, false);
            crit.add(IssuePeer.MOVED, false);
            result = ((Record)ActivityPeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
        }
        
        return result;
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static String handleRequest(Context context, String template)
        throws Exception
    {
        return getService().handleRequest(context, template);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public String handleRequest(Context context, String template,
                                String charset, String encoding)
        throws Exception
    {
        return getService().handleRequest(context, template, charset,
                                          encoding);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static void handleRequest(Context context, String template,
                                     OutputStream out)
        throws Exception
    {
        getService().handleRequest(context, template, out);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static void handleRequest(Context context, String template,
                                     OutputStream out, String charset,
                                     String encoding)
        throws Exception
    {
        getService().handleRequest(context, template, out, charset, encoding);
    }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
private void initdb(Locale defaultLocale)
        throws Exception
    {
        String[][] methodNames = getInputData();        
        Class[] stringSig = {String.class};
        Class[] critSig = {Criteria.class};

        for (int m=0; m<methodNames.length; m++) 
        {
            String[] row = methodNames[m];
            String omClassName = "org.tigris.scarab.om." + row[1];
            Class peerClass = Class.forName(omClassName + "Peer");
            Object peerObject = peerClass.newInstance();

            Method doSelect = peerClass.getMethod("doSelect", critSig);
            Object[] critArg = {new Criteria()};
            List omlist = (List)doSelect.invoke(peerObject, critArg);
            if (!omlist.isEmpty()) 
            {
                Class omClass = Class.forName(omClassName);
                int nbrBeanMethods = row.length - 2;
                Method[] getters = new Method[nbrBeanMethods];
                Method[] setters = new Method[nbrBeanMethods];
                for (int n=2; n<row.length; n++) 
                {
                    getters[n-2] = omClass.getMethod("get"+row[n], (java.lang.Class)null);
                    setters[n-2] = omClass.getMethod("set"+row[n], stringSig);
                }
                Method save = omClass.getMethod("save", (java.lang.Class)null);

                Iterator i = omlist.iterator();
                while (i.hasNext()) 
                {
                    Object om = i.next();
                    for (int n=0; n<getters.length; n++) 
                    {
                        Log.get().debug("Converting " + row[1] + '.' + 
                                        getters[n].getName());
                        String key = (String)getters[n].invoke(om, (java.lang.Object)null);
                        String value = null;

                        // Oracle returns null on empty field.
                        if (key != null)
                        {
                            try 
                            {
                                value = Localization.getString(row[0], 
                                                               defaultLocale,
                                                               key);
                            }
                            catch (MissingResourceException e)
                            {
                                Log.get().debug("Missing database initialization "
                                                + "resource: " + e.getMessage());
                            } 
                        }
                        if (value != null) 
                        {
                            Object[] arg = {value};
                            setters[n].invoke(om, arg);
                        }
                    }
                    save.invoke(om, (java.lang.Object)null);
                } 
            }
        }
    }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
private void checkNewHttpParameters()
        throws Exception
    {
        String oldDomain = GlobalParameterManager
            .getString(ScarabConstants.HTTP_DOMAIN);
        String oldScheme = GlobalParameterManager
            .getString(ScarabConstants.HTTP_SCHEME);
        String oldScriptName = GlobalParameterManager
            .getString(ScarabConstants.HTTP_SCRIPT_NAME);
        String oldPort = GlobalParameterManager
            .getString(ScarabConstants.HTTP_PORT);

        if (oldDomain.equals(""))
        {
            // installations with post-b15 but pre-b16 may have module
            // specific values.  
            Criteria crit = new Criteria();
            crit.add(GlobalParameterPeer.NAME, MODULE_DOMAIN);
            List parameters = GlobalParameterPeer.doSelect(crit);
            if (!parameters.isEmpty()) 
            {
                oldDomain = ((GlobalParameter)parameters.get(0)).getValue();
            }

            crit = new Criteria();
            crit.add(GlobalParameterPeer.NAME, MODULE_SCHEME);
            parameters = GlobalParameterPeer.doSelect(crit);
            if (!parameters.isEmpty()) 
            {
                oldScheme = ((GlobalParameter)parameters.get(0)).getValue();
            }

            crit = new Criteria();
            crit.add(GlobalParameterPeer.NAME, MODULE_SCRIPT_NAME);
            parameters = GlobalParameterPeer.doSelect(crit);
            if (!parameters.isEmpty()) 
            {
                oldScriptName = 
                    ((GlobalParameter)parameters.get(0)).getValue();
            }

            crit = new Criteria();
            crit.add(GlobalParameterPeer.NAME, MODULE_PORT);
            parameters = GlobalParameterPeer.doSelect(crit);
            if (!parameters.isEmpty()) 
            {
                oldPort = ((GlobalParameter)parameters.get(0)).getValue();
            }
        }

        String newValue = Turbine.getConfiguration()
            .getString(ScarabConstants.HTTP_DOMAIN);
        if (newValue != null && newValue.trim().length() != 0
            && !newValue.equals(oldDomain)) 
        {
            GlobalParameterManager
                .setString(ScarabConstants.HTTP_DOMAIN, newValue);
            fixIssueIdCounters(oldDomain, newValue);
        }

        newValue = Turbine.getConfiguration()
            .getString(ScarabConstants.HTTP_SCHEME);
        if (newValue != null && newValue.trim().length() != 0
            && !newValue.equals(oldScheme)) 
        {
            GlobalParameterManager
                .setString(ScarabConstants.HTTP_SCHEME, newValue);
        }

        newValue = Turbine.getConfiguration()
            .getString(ScarabConstants.HTTP_SCRIPT_NAME);
        if (newValue != null && newValue.trim().length() != 0
            && !newValue.equals(oldScriptName)) 
        {
            GlobalParameterManager
                .setString(ScarabConstants.HTTP_SCRIPT_NAME, newValue);
        }

        newValue = Turbine.getConfiguration()
            .getString(ScarabConstants.HTTP_PORT);
        if (newValue != null && newValue.trim().length() != 0
            && !newValue.equals(oldPort)) 
        {
            GlobalParameterManager
                .setString(ScarabConstants.HTTP_PORT, newValue);
        }
    }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
private void fixIssueIdCounters(String oldDomain, String newDomain)
        throws Exception
    {
        String sql = 
            "select NEXT_ID from ID_TABLE where TABLE_NAME='ID_TABLE'";
        Connection con = null;
        try 
        {
            con = Torque.getConnection();
            Statement s = con.createStatement();
            ResultSet rs = s.executeQuery(sql);
            int maxId = 0;
            if (rs.next()) 
            {
                maxId = rs.getInt(1);
            }
            s.close();

            for (int id = 1000; id <= maxId; id++) 
            {
                sql = "select TABLE_NAME from ID_TABLE where ID_TABLE_ID=" 
                    + id;
                s = con.createStatement();
                rs = s.executeQuery(sql);
                if (rs.next()) 
                {
                    String oldKey = rs.getString(1);
                    s.close();
                    int hyphenPos = oldKey.indexOf('-');
                    String newKey = null;
                    if ( (oldDomain == null || oldDomain.length() == 0)
                         && hyphenPos <= 0) 
                    {
                        newKey = newDomain + '-' + oldKey;
                    }
                    else 
                    {
                        String prefix = oldKey.substring(0, hyphenPos);
                        String code = oldKey.substring(hyphenPos+1);
                        if (prefix.equals(oldDomain)) 
                        {
                            newKey = newDomain + '-' + code;
                        }
                    }
                    
                    if (newKey != null) 
                    {
                        sql = "update ID_TABLE set TABLE_NAME='" + newKey +
                            "' where ID_TABLE_ID=" + id;
                        s = con.createStatement();
                        s.executeUpdate(sql);
                        s.close();
                    }
                }
            }
        }
        finally
        {
            if (con != null) 
            {
                con.close();
            }
        }
    }
            
// in java/org/tigris/scarab/services/TorqueService.java
protected void loadOM()
        throws Exception
    {
        ActivityManager.getInstance();
        ActivitySetManager.getInstance();
        ActivitySetTypeManager.getInstance();
        AttachmentManager.getInstance();
        AttachmentTypeManager.getInstance();
        AttributeClassManager.getInstance();
        AttributeGroupManager.getInstance();
        AttributeManager.getInstance();
        AttributeOptionManager.getInstance();
        AttributeTypeManager.getInstance();
        // AttributeValue class is abstract
        AttributeValueManager.getManager();
        Class.forName("org.tigris.scarab.om.AttributeValue");
        DependManager.getInstance();
        DependTypeManager.getInstance();
        FrequencyManager.getInstance();
        GlobalParameterManager.getInstance();
        // Issue class does not have public no-arg ctor
        IssueManager.getManager();
        Class.forName("org.tigris.scarab.om.Issue");
        IssueTemplateInfoManager.getInstance();
        IssueTypeManager.getInstance();
        IssueVoteManager.getInstance();
        MITListItemManager.getInstance();
        MITListManager.getInstance();
        ModificationManager.getInstance();
        ModuleManager.getInstance();
        OptionRelationshipManager.getInstance();
        PendingGroupUserRoleManager.getInstance();
        QueryManager.getInstance();
        RAttributeAttributeGroupManager.getInstance();
        ReportManager.getInstance();
        RIssueTypeAttributeManager.getInstance();
        RIssueTypeOptionManager.getInstance();
        RModuleAttributeManager.getInstance();
        RModuleIssueTypeManager.getInstance();
        RModuleOptionManager.getInstance();
        RModuleUserAttributeManager.getInstance();
        // ROptionOption class does not have public no-arg ctor
        ROptionOptionManager.getManager();
        Class.forName("org.tigris.scarab.om.ROptionOption");
        RQueryUserManager.getInstance();
        ScarabUserManager.getInstance();
        ScopeManager.getInstance();
        UserPreferenceManager.getInstance();
        UserVoteManager.getInstance();
    }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }

        JCSCache = JCS.getInstance(SCARAB_CACHE_REGION);

        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }

    }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
        maps = new WeakHashMap();
        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
        
    }
            
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
public void synchUser(SearchResult sr) throws Exception {
		Attributes attributes = sr.getAttributes();
		
		String uid = (String) attributes.get(loginAttribute).get(0);
		logger.info("uid : " + uid);

        boolean isNewUser = false;
		ScarabUser user = ScarabUserManager.getInstance(uid);
		if (user == null) {
			user = ScarabUserManager.getInstance();
			isNewUser = true;
		}

		user.setEmail(getAttributeValue(attributes.get("mail"), "Unknown"));
		user.setLastName(getAttributeValue(attributes.get("sn"), "Unknown"));
		user.setFirstName(getAttributeValue(attributes.get("givenName"),
				"Unknown"));

		if(isNewUser)
		{
            user.setName(uid);
            // Generate random password to avoid security hole.
            // This will be reset when the user logs in the first time
            user.setPassword(PasswordGenerator.generate());
            user.createNewUser();
            ScarabUserImpl.confirmUser(uid);
		} 
		else
		{    
		    user.save();
		}
	}
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
protected boolean checkExists(Group group)
        throws DataBackendException, Exception
    {
        return ScarabModulePeer.checkExists(group);
    }
            
// in java/org/tigris/scarab/util/ScarabLink.java
public ScarabLink getIssueIdLink(Issue issue)
        throws Exception
    {
        this.addPathInfo("id", issue.getUniqueId());
        return this;
    }
            
// in java/org/tigris/scarab/util/ScarabLink.java
public ScarabLink getIssueIdAbsoluteLink(Issue issue)
        throws Exception
    {
        ScarabLink link = getIssueIdLink(issue);
        link.setRelative(false).setEncodeUrl(false);
        return link;
    }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
public static String linkifyText(String input, ScarabLink link, Module module)
        throws Exception
    {
        StringBuffer sb = new StringBuffer(input.length() * 2);
        List result = IssueIdParser.tokenizeText(module, input);
        for (Iterator itr = result.iterator(); itr.hasNext();)
        {
            Object tmp = itr.next();
            if (tmp instanceof String)
            {
                sb.append(tmp);
            }
            else
            {
                final List tmpList = (List)tmp;
                final String id = (String)tmpList.get(1);
                final Issue issue = IssueManager.getIssueById(id);
                
                if(issue != null){
                	 final String defaultText = issue.getDefaultText();
                     final String attributes = "alt=\"" + defaultText + "\" title=\"" + defaultText + "\"";

                     link.addPathInfo("id", id);
                     link.addPathInfo("tab", "1");
                     link.setLabel((String)tmpList.get(0));
                     final String bar = link.setAttributeText(attributes).toString();
                     sb.append(bar);
                }
                else{
                	//write token back, no valid issue found for linking
                	sb.append((String)tmpList.get(0));	
                }
               
            }
        }
        return sb.toString();
    }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
public static StringValueParser parseURL(String url) throws Exception
    {
        StringValueParser parser = new StringValueParser();
        parser.setCharacterEncoding("UTF-8");
        parser.parse(url, '&', '=', true);
        return parser;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearchFactory.java
public IssueSearch getInstance(Issue issue, ScarabUser searcher)
        throws Exception
    {
        return new IssueSearch(issue, searcher);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearchFactory.java
public IssueSearch
        getInstance(Module module, IssueType issueType, ScarabUser searcher)
        throws Exception
    {
        return new IssueSearch(module, issueType, searcher);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearchFactory.java
public IssueSearch getInstance(MITList mitList, ScarabUser searcher)
        throws Exception
    {
        return new IssueSearch(mitList, searcher);
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public List executeQuery(TextQuery textQuery) 
        throws Exception
    {
        String queryText = textQuery.toString();
        
        Query luceneQuery;
        try
        {
           luceneQuery = new QueryParser("", analyzer).parse(queryText);
        }
        catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }

        List issueIds = new ArrayList();
        IndexSearcher is = new IndexSearcher(indexDir); 
        try
        {
            Hits hits = is.search(luceneQuery);
            
            for(Iterator hi = hits.iterator(); hi.hasNext();)
            {
                Hit h = (Hit)hi.next();
                issueIds.add( Long.valueOf(h.get(ISSUE_ID)));
            }
        }
        finally
        {
            is.close();
        }        
        return issueIds;
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void index(Issue issue)
    throws Exception
    {
        Document doc = document(issue);
        synchronized(this)
        {
            update(doc);
            optimize(false);
            flush();
        }
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private void update(Document doc)
    throws Exception
    {    
        writer.updateDocument(new Term( ISSUE_ID, doc.get(ISSUE_ID) ), doc); 
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private void rebuild(RebuildMonitor rebuildMonitor)
        throws Exception
    {        
        Criteria crit = new Criteria()
            .add(IssuePeer.DELETED, false);
        
        List issues = IssuePeer.doSelect(crit);
        rebuildMonitor.setNoIssues(issues.size());
        
        for(Iterator issuei = issues.iterator(); issuei.hasNext();) 
        {            
            Document doc = document((Issue)issuei.next());
            synchronized(this){
                update(doc);                
                rebuildMonitor.issueProcessed();
            }
            
            if(rebuildMonitor.iscancelled()) return;
        }  

        synchronized(this)
        {
            optimize(true);        
            flush();
        }
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void initialize()
        throws Exception
    {
        Configuration cfg = Turbine.getConfiguration().subset("searchindex");
        String indexPath = cfg.getString(INDEX_PATH, null);
        String analyzerClassName = cfg.getString(ANALYZER_CLASS, null);
        
        File absIndexPath = getIndexDir(indexPath, applicationRoot);
        
        indexDir = FSDirectory.getDirectory(absIndexPath, new NativeFSLockFactory(absIndexPath));
        
        boolean createIndex = !IndexReader.indexExists(indexDir);
        
        analyzer = createAnalyzer(analyzerClassName);

        writer = new IndexWriter(indexDir, analyzer, createIndex);
 
        if(createIndex) startRebuild();        
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public Map getAttributeValuesMap(boolean commonOnly) throws Exception
    {
       	Map result = null;

        List attributes;
        if(commonOnly)
        {
            attributes = mitList.getCommonAttributes(false);
        }
        else
        {
            attributes = mitList.getAttributes(false,false);
        }

        Map siaValuesMap = searchIssue.getAttributeValuesMap();
        if (attributes != null) 
        {
            result = new LinkedMap((int)(1.25*attributes.size() + 1));
            Iterator i = attributes.iterator();
            while (i.hasNext()) 
            {
                Attribute attribute = (Attribute)i.next();
                String key = attribute.getName().toUpperCase();
                if (siaValuesMap.containsKey(key)) 
                {
                    result.put(key, siaValuesMap.get(key));
                }
                else 
                {
                    AttributeValue aval = AttributeValue
                        .getNewInstance(attribute, searchIssue);
                    searchIssue.addAttributeValue(aval);
                    result.put(key, aval);
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getUserAttributes()
        throws Exception
    {
        return mitList.getCommonUserAttributes(false);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getLeafRModuleOptions(Attribute attribute)
        throws Exception
    {
        return mitList.getCommonLeafRModuleOptions(attribute);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getCommonOptionTree(Attribute attribute)
        throws Exception
    {
        return mitList.getCommonRModuleOptionTree(attribute);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getAllOptionTree(Attribute attribute)
        throws Exception
    {
        return mitList.getAllRModuleOptionTree(attribute);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public Integer[] getTextScope()
        throws Exception
    {
        if (textScope == null) 
        {
            textScope = getTextScopeForAll();
        }
        return textScope;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Integer[] getTextScopeForAll()
        throws Exception
    {
        Integer[] textScope = null;
        List textAttributes = getQuickSearchTextAttributeValues();
        if (textAttributes != null) 
        {
            textScope = new Integer[textAttributes.size()];
            for (int j=textAttributes.size()-1; j>=0; j--) 
            {
                textScope[j] = ((AttributeValue)
                                textAttributes.get(j)).getAttributeId();
            }
        }
        return textScope;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public void setTextScope(Integer[] v) 
        throws Exception
    {
        this.textScope = v;            
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getQuickSearchTextAttributeValues()
        throws Exception
    {
        return getTextAttributeValues(true);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getTextAttributeValues()
        throws Exception
    {
        return getTextAttributeValues(false);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private List getTextAttributeValues(boolean quickSearchOnly)
        throws Exception
    {
    	Map searchValues = getAttributeValuesMap(true);
        List searchAttributes = new ArrayList(searchValues.size());

        for (Iterator i=searchValues.values().iterator(); i.hasNext();) 
        {
            AttributeValue searchValue = (AttributeValue)i.next();
            if ((!quickSearchOnly || searchValue.isQuickSearchAttribute())
                 && searchValue.getAttribute().isTextAttribute()) 
            {
                searchAttributes.add(searchValue);
            }
        }

        return searchAttributes;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getQuickSearchOptionAttributeValues()
        throws Exception
    {
        Map searchValues = getAttributeValuesMap(true);
		List searchAttributeValues = new ArrayList(searchValues.size());
		
		for (Iterator i= searchValues.values().iterator();i.hasNext();) 
		{
		    AttributeValue searchValue = (AttributeValue)i.next();
		    if (searchValue.isQuickSearchAttribute()
		         && searchValue instanceof OptionAttribute) 
		    {
		        searchAttributeValues.add(searchValue);
		    }
		}
		
		return searchAttributeValues;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void setDefaults(Issue.FederatedId minFid, 
                             Issue.FederatedId maxFid)
        throws Exception
    {
        Module module = singleModule;
        if (module != null) 
        {
            if (minFid != null && minFid.getDomain() == null) 
            {
                minFid.setDomain(module.getScarabInstanceId());
            }
            if (maxFid != null && maxFid.getDomain() == null) 
            {
                maxFid.setDomain(module.getScarabInstanceId());
            }
            if (minFid != null && minFid.getPrefix() == null) 
            {
                minFid.setPrefix(module.getCode());
            }            
        }
        if (maxFid != null && maxFid.getPrefix() == null) 
        {
            if (minFid == null) 
            {
                maxFid.setPrefix(module.getCode());                
            }
            else 
            {
                maxFid.setPrefix(minFid.getPrefix());        
            }
        }
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void buildOptionList(List options, AttributeValue aval)
        throws Exception
    {
        List descendants =  mitList.getDescendantsUnion(aval.getAttributeOption());
        
        // Include the selected attribute value as one of the options
        // to search for.
        options.add(aval.getOptionId());
        
        if (descendants != null && !descendants.isEmpty())
        {
            // Add all applicable child attribute options to the list as well.
            for (Iterator i = descendants.iterator(); i.hasNext();) 
            {
                options.add(((RModuleOption)i.next())
                    .getOptionId());
            }
        }
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private List getTextMatches()
        throws Exception
    {
        TextQuery query = new  TextQuery();

        if (isSimpleTextQuery())
        {
            query.addAttrClauses(getSimpleTextClauses());
        }
        else 
        {
            List setAttValues = getSetAttributeValues();
            for (Iterator i = setAttValues.iterator(); i.hasNext();) 
            {
                AttributeValue aval = (AttributeValue)i.next();

                if (aval instanceof DateAttribute)
                {
                    query.addAttrClause(getDateAttributeClause(aval));
                }
                else if (aval instanceof StringAttribute)
                {
                	AttributeValue copyAval = aval.copy();
                	copyAval.setValue(QueryParser.escape(copyAval.getValue()));
                    query.addAttrClause(copyAval);
                }
            }
        }

        query.addCommentClause(getCommentQuery());
        
        query.setAnd(!getMergePartialTextQueries());

        List matchingIssueIds = null;
        if(!query.isEmpty())
        {
            LuceneSearchIndex LuceneSearchIndex = SearchFactory.getInstance();
            try 
            {
                matchingIssueIds = LuceneSearchIndex.executeQuery(query);    
            }
            finally
            {
                SearchFactory.releaseInstance(LuceneSearchIndex);
            }
        }
        return matchingIssueIds;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private AttributeValue getDateAttributeClause(AttributeValue aval) 
        throws Exception
    {
        //FIXME remove auxDate workaround for date ranges
        AttributeValue auxAval = aval.getChainedValue();

        Date date = parseDate(aval.getValue(), false); 
        Date auxDate = date;
        if(auxAval != null &&
           emptyString2null(auxAval.getValue()) != null)
        {
        	auxDate = parseDate(auxAval.getValue(), true);                        	
        }
        String clause;
        if (date.equals(auxDate))
        {    
        	clause = DateAttribute.internalDateFormat(date);
        }
        else
        {
            clause =
                "[" + DateAttribute.internalDateFormat(date) + " TO " 
                    + DateAttribute.internalDateFormat(auxDate) + "]"
            ;
      
        }
        StringAttribute clauseAV = new StringAttribute();
        clauseAV.setAttributeId(aval.getAttributeId());
        clauseAV.setValue(clause);
        return clauseAV;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private List getSimpleTextClauses() throws Exception
    {
        String clause = getSearchWords();
        List textClauses = new ArrayList();
        Integer[] attributeIds = getTextScope();
        
        for(int i=0;i<attributeIds.length;i++){
            StringAttribute clauseAV = new StringAttribute();
            clauseAV.setAttributeId(attributeIds[i]);
            clauseAV.setValue(clause);
            textClauses.add(clauseAV);
            
        }
        return textClauses;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Criteria getCoreSearchCriteria(List issueIdsMatchedText)
        throws java.lang.Exception
    {
        Criteria crit = new Criteria();

        crit.addSelectColumn(IssuePeer.ISSUE_ID)
            .and(IssuePeer.DELETED, false)
            .and(IssuePeer.MOVED, false);

        crit.setDistinct();

        addMITCriteria(crit);
        
        addIssueIdRangeCriteria(crit);

        addAttributeOptionCriteria(crit);

        addMatchedTextCriteria(crit, issueIdsMatchedText);

        addDateCriteria(crit);

        addUserCriteria(crit);

        addStateChangeCriteria(crit);

        addSortCriteria(crit);
        
        return crit;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addStateChangeCriteria(Criteria crit)
        throws Exception
    {
        Integer oldOptionId = getStateChangeFromOptionId();
        Integer newOptionId = getStateChangeToOptionId();

        if ((oldOptionId != null &&  !oldOptionId.equals(NUMBERKEY_0))
            || (newOptionId != null && !newOptionId.equals(NUMBERKEY_0))
            || getStateChangeFromDate() != null 
            || getStateChangeToDate() != null)
        {
            crit.addAlias(STATE_CHANGE_TABLE, ActivityPeer.TABLE_NAME);
            crit.addJoin( 
                IssuePeer.ISSUE_ID, 
                useAlias(STATE_CHANGE_TABLE,ActivityPeer.ISSUE_ID), 
                Criteria.INNER_JOIN 
            );

            if (oldOptionId == null && newOptionId == null)
            {
                crit.and(useAlias(STATE_CHANGE_TABLE,ActivityPeer.ATTRIBUTE_ID), 
                         getStateChangeAttributeId(),
                         Criteria.EQUAL);
            }
            else
            {
                if (newOptionId != null && !newOptionId.equals(NUMBERKEY_0)) 
                {
                    crit.and(useAlias(STATE_CHANGE_TABLE,ActivityPeer.NEW_OPTION_ID), 
                             newOptionId,
                             Criteria.EQUAL);
                }
                if (oldOptionId != null && !oldOptionId.equals(NUMBERKEY_0))
                {
                    crit.and(useAlias(STATE_CHANGE_TABLE,ActivityPeer.OLD_OPTION_ID), 
                             oldOptionId,
                             Criteria.EQUAL);
                }
            }
            if (getStateChangeFromDate() != null || getStateChangeToDate() != null)
            {
                crit.addAlias(STATE_CHANGE_DATE_TABLE, ActivitySetPeer.TABLE_NAME);

                crit.addJoin( 
                    useAlias(STATE_CHANGE_TABLE, ActivityPeer.TRANSACTION_ID), 
                    useAlias(STATE_CHANGE_DATE_TABLE, ActivitySetPeer.TRANSACTION_ID), 
                    Criteria.INNER_JOIN 
                );
               addDateRangeCriteria( crit, useAlias(STATE_CHANGE_DATE_TABLE, ActivitySetPeer.CREATED_DATE), 
                                getStateChangeFromDate(), getStateChangeToDate());
            }
        }
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addDateCriteria(Criteria crit)
        throws Exception
    {        
        addTransDateRange(crit, "CHANGE_DATE_TABLE", IssuePeer.LAST_TRANS_ID,
                          getMinChangeDate(), getMaxChangeDate());
        addTransDateRange(crit, "CREATE_DATE_TABLE", IssuePeer.CREATED_TRANS_ID,
                          getMinCreationDate(), getMaxCreationDate());
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addUserCriteria(Criteria crit)
        throws Exception
    {        
        List anyUsers = new ArrayList();
        List creatorUsers = new ArrayList();

        for (Iterator i = searchUsers.entrySet().iterator(); i.hasNext();)
        {                
            Map.Entry entry = (Map.Entry)i.next();
            String userId = (String)entry.getKey();
            Set attrIds = (Set)entry.getValue();

            for ( Iterator i2 = attrIds.iterator(); i2.hasNext();)
            {
                String attrId = (String)i2.next();

    	        if(SEARCHING_USER_KEY.equalsIgnoreCase(userId))
    	        {
    	            userId=searchingUser.getUserId().toString();
    	        }
            
    	        if(ANY_KEY.equals(attrId))
    	        {
    	        	anyUsers.add(userId);
    	        }
    	        else if (CREATED_BY_KEY.equals(attrId)) 
    	        {
    	            creatorUsers.add(userId);
    	        }
    	        else 
    	        {
    	           //Normal user attributes will be added as attributes in 'addAttributeOptionCriteria'.
    	        }

            }
        }

        if (anyUsers.size()>0 || creatorUsers.size()>0)
        {
            crit.addAlias("USER_TABLE", ActivityPeer.TABLE_NAME);
            crit.addJoin( 
                IssuePeer.ISSUE_ID, 
                useAlias("USER_TABLE",ActivityPeer.ISSUE_ID), 
                Criteria.INNER_JOIN 
            );
        }                

        if (anyUsers.size()>0)
        {
            crit.addIn(useAlias("USER_TABLE",ActivityPeer.NEW_USER_ID), anyUsers);
        }                                     
        
        if (anyUsers.size()>0 || creatorUsers.size()>0)
        {
            List anyAndCreators = new ArrayList();
            anyAndCreators.addAll(anyUsers);
            anyAndCreators.addAll(creatorUsers);

            crit.addAlias("CREATOR_USER_TABLE", ActivitySetPeer.TABLE_NAME);
            crit.addJoin( 
                IssuePeer.CREATED_TRANS_ID, 
                useAlias("CREATOR_USER_TABLE",ActivitySetPeer.TRANSACTION_ID), 
                Criteria.INNER_JOIN 
            );

            Criteria.Criterion userIds4anyAndCreators = crit.getNewCriterion(
                useAlias("CREATOR_USER_TABLE",ActivitySetPeer.CREATED_BY),
                anyAndCreators,
                Criteria.IN
            );

            Criteria.Criterion c = crit.getCriterion(useAlias("USER_TABLE",ActivityPeer.NEW_USER_ID));
            if(c!=null)
            {
            	c.or(userIds4anyAndCreators);
            }
            else
            {
            	crit.add(userIds4anyAndCreators);
            }
        }
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addIssueIdRangeCriteria(Criteria crit)
        throws java.lang.Exception
    {
        Issue.FederatedId minFid = null;
        Issue.FederatedId maxFid = null;

        if(minId != null)
        {
            minFid = new Issue.FederatedId(minId);
        }
        if(maxId != null)
        {
            maxFid = new Issue.FederatedId(maxId);
        }
        setDefaults(minFid, maxFid);

        if ( minFid != null
          && maxFid != null
          && (   minFid.getCount() > maxFid.getCount() 
              || !StringUtils.equals(minFid.getPrefix(), maxFid.getPrefix())
              || !StringUtils.equals(minFid.getDomain(), maxFid.getDomain())))
        {
            throw new ScarabException(L10NKeySet.ExceptionIncompatibleIssueIds, minId, maxId);
        }
        else 
        {
            addIssueIdCrit(crit, minFid, Criteria.GREATER_EQUAL );
            addIssueIdCrit(crit, maxFid, Criteria.LESS_EQUAL );
        }        
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addAttributeOptionCriteria(Criteria crit)
        throws java.lang.Exception
    {
        List setAttValues = getSetAttributeValues();

		//get attributes avlues as flat list
        Map attrMap = new HashMap((int)(setAttValues.size()*1.25));
        for (int j=0; j<setAttValues.size(); j++) 
        {
            AttributeValue multiAV = (AttributeValue)setAttValues.get(j);
            if (multiAV instanceof OptionAttribute)
            {                
                //pull any chained values out to create a flat list
                List flatOptions = new ArrayList();
                List chainedValues = multiAV.getValueList();
                for (int i=0; i<chainedValues.size(); i++) 
                {
                    AttributeValue aval = (AttributeValue)chainedValues.get(i);
                    Integer optionId = aval.getOptionId();
                    if(optionId == null)
                    {
                        continue;
                    }
                    if (optionId.intValue() != 0) // Empty value is 0
                    {
                        buildOptionList(flatOptions, aval);
                    }
                    else
                    {
                        flatOptions.add(optionId);
                    }
                }

                Integer attributeId = multiAV.getAttributeId();
                attrMap.put(attributeId, flatOptions);
            }
        }

		//add misc attribute values for search
        for (Iterator i=attrMap.entrySet().iterator(); i.hasNext();) 
        {
            Map.Entry options4Attribute = (Map.Entry)i.next();
            List options = (List) options4Attribute.getValue();
            Integer attributeId = (Integer) options4Attribute.getKey();
            String alias = "av" + attributeId;
            
            crit.addAlias(alias, AttributeValuePeer.TABLE_NAME);
            joinAttributeValue(crit, alias, attributeId, Criteria.LEFT_JOIN);
             
            crit.andIn(useAlias(alias, AttributeValuePeer.OPTION_ID), options );

            if (options.contains(NUMBERKEY_0)) //is 'empty' option selected?
            {                
                crit.or(useAlias(alias, AttributeValuePeer.OPTION_ID), (Object) null, Criteria.ISNULL);
            }
        }

        Map searchUserAttributes = getSearchUserAttributes();
        
		//add values for user attributes
        for (Iterator i=searchUserAttributes.entrySet().iterator(); i.hasNext();) 
        {
        	
            Map.Entry entry = (Map.Entry)i.next();
            String strAttributeId = (String)entry.getKey();
            Set userIds = (Set)entry.getValue();
            List searchUsersList = new ArrayList();
        	
            if(!ANY_KEY.equals(strAttributeId)
        			&& !CREATED_BY_KEY.equals(strAttributeId)){
        		int attributeId = Integer.parseInt(strAttributeId);
            	//add search values for user attributes
            	String alias = "av" + attributeId;            
                crit.addAlias(alias, AttributeValuePeer.TABLE_NAME);
                joinAttributeValue(crit, alias, attributeId, Criteria.LEFT_JOIN);
                
                for ( Iterator i2 = userIds.iterator(); i2.hasNext();)
                {          	           	
                	String strUserId = (String)i2.next();
                	if(SEARCHING_USER_KEY.equalsIgnoreCase(strUserId)) 
        	        {
                		//Special user criteria. These are handled by method 'addUserCriteria'.
        	        }
        	        else{
    	                searchUsersList.add(strUserId);
        	        }
                }
                crit.andIn(useAlias(alias, AttributeValuePeer.USER_ID), searchUsersList );
        	}                      
            
        }

    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getQueryResults()
        throws Exception
    {
    	List queryResults = Collections.EMPTY_LIST;            
        Criteria c = getSearchCriteria();
        if(c!=null)
        {
            queryResults = getQueryResults(c);
        }
        return queryResults;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public int getIssueCount()
        throws Exception
    {
        int count = 0;
        Criteria c = getSearchCriteria();
        if(c!=null)
        {
            count = (new CachedQuery(c, true)).getRowCount();
        }
        return count;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Criteria getSearchCriteria()
        throws Exception
    {
        Criteria c = null;
    	if (isSearchAllowed) 
        {
            List issueIdsMatchedText = getTextMatches();
            
            if (issueIdsMatchedText==null || issueIdsMatchedText.size() > 0) 
            {            
            	c = getCoreSearchCriteria(issueIdsMatchedText);
            }
        }
        return c;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private List getQueryResults(Criteria c)
        throws Exception
    {
        return new QueryResultList(new CachedQuery(c, false));
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public void setQueryKey(String key)
        throws Exception
    {
    }
            
// in java/org/tigris/scarab/util/Email.java
public static void sendEmail(EmailContext context, Module module,
                                    Object fromUser, Object replyToUser,
                                    ScarabUser toUser, String template)
            throws Exception
    {
        Collection toUsers = new ArrayList(2);
        toUsers.add(toUser);
        sendEmail(context, module, fromUser, replyToUser, toUsers, null,
                template);
    }
            
// in java/org/tigris/scarab/util/Email.java
public static void sendEmail(EmailContext context, Module module,
                                    Object fromUser, Object replyToUser,
                                    Collection toUsers, Collection ccUsers,
                                    String template) 
        throws Exception
    {
        if (!GlobalParameterManager.getBoolean(GlobalParameter.EMAIL_ENABLED,
                module))
        {
            return;
        }

        //
        // To avoid any NullPointerExceptions, create
        // empty lists of to: and cc: users if the
        // collections are null.
        //
        if (toUsers == null)
        {
            toUsers = new ArrayList();
        }

        if (ccUsers == null)
        {
            ccUsers = new ArrayList();
        }

        //
        // Remove duplicate addresses from the cc: list
        //
        ccUsers.removeAll(toUsers);        

        Map userLocaleMap = groupAddressesByLocale(module, toUsers, ccUsers);

        for (Iterator i = userLocaleMap.keySet().iterator(); i.hasNext();)
        {
            Locale locale = (Locale) i.next();
            List[] toAndCC = (List[]) userLocaleMap.get(locale);
            List to = toAndCC[TO];
            List cc = toAndCC[CC];

            sendEmailInLocale(context, module, fromUser, replyToUser, to, cc,
                              template, locale);
        }

    }
            
// in java/org/tigris/scarab/util/Email.java
private static void sendEmailInLocale(EmailContext context, Module module,
                                          Object fromUser, Object replyToUser,
                                          List toAddresses, List ccAddresses,
                                          String template, Locale locale)
        throws Exception
    {
        log.debug("Sending email for locale=" + locale);

        // get reference to l10n tool, so we can alter the locale per email
        ScarabLocalizationTool l10n = new ScarabLocalizationTool();
        context.setLocalizationTool(l10n);
        l10n.init(locale);

        Email te = getEmail(context, module, fromUser, replyToUser, template);

        final String charSet = getCharset(locale);
        te.setCharset(charSet);
        context.put("charSet", new String(charSet));
        
        //te.addHeader("Content-Base: "");

        boolean atLeastOneTo = false;
        for (Iterator iTo = toAddresses.iterator(); iTo.hasNext();)
        {
            InternetAddress a = (InternetAddress) iTo.next();
            log.debug("Adding To: email[" + a.getAddress() + "], name["+a.getPersonal()+"]");
            te.addTo(a.getAddress(), a.getPersonal());
            atLeastOneTo = true;
        }
        for (Iterator iCC = ccAddresses.iterator(); iCC.hasNext();)
        {
            InternetAddress a = (InternetAddress) iCC.next();
            String email = a.getAddress();
            String name = a.getPersonal();

            
            // template email requires a To: user, it does seem possible
            // to send emails with only a CC: user, so not sure if this
            // is a bug to be fixed in TemplateEmail.  Might not be good
            // form anyway.  So if there are no To: users, upgrade CC's.
            if (atLeastOneTo)
            {
                log.debug("Adding CC: email[" + email + "], name["+name+"]");
                te.addCc(email, name);
            }
            else
            {
                log.debug("Adding to: email[" + email + "], name["+name+"]");
                te.addTo(email, name);
                // We've added one To: user and TemplateEmail should be
                // happy. No need to move all CC: into TO:
                atLeastOneTo = true;
            }
        }

        // Email threading -- applicable to issue related notifications
        Issue issue = null;
        String emailReferences = null;
        if(context.containsKey("issue"))
        {
            issue = (Issue) context.get("issue");
            emailReferences = null != issue.getEmailReferences()
                    ? issue.getEmailReferences()
                    : "";
            if(0 != emailReferences.length())
            {
                te.addHeader("References", emailReferences);
            }
        }

        String newEmailReference = null;
        try
        {
            log.debug("Sending email ...");
            newEmailReference = te.send();
            log.debug("... sent " + newEmailReference);
        }
        catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }

        if(null!=emailReferences && null!=newEmailReference)
        {
            // we record, within the varchar(2000) limit,
            // the MessageID of every mail sent if it's related to an issue change 
            // There must be an error in the length calculation, which sometimes causes
            // the issue.save() to throw an illegalLength exception. I tried to take care
            // of this here. [HD]

            if(emailReferences.length()>0) emailReferences += ' ';
            emailReferences += newEmailReference; 

            if(emailReferences.length() > 2000)
            {
                emailReferences = emailReferences.substring(
                        emailReferences.indexOf('<', emailReferences.length() - 2000));
            }
            try
            {
                issue.setEmailReferences(emailReferences);
                issue.save();
            }
            catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
        }
    }
            
// in java/org/tigris/scarab/util/Email.java
private static Map groupAddressesByLocale(Module module,
                                              Collection toUsers,
                                              Collection ccUsers)
        throws Exception
    {
        Map result = new HashMap();
        for (Iterator iter = toUsers.iterator(); iter.hasNext();)
        {
            fileUser(result, (ScarabUser) iter.next(), module, TO);
        }

        for (Iterator iter = ccUsers.iterator(); iter.hasNext();)
        {
            fileUser(result, (ScarabUser) iter.next(), module, CC);
        }
        return result;
    }
            
// in java/org/tigris/scarab/util/Email.java
private static void fileUser(Map userLocaleMap, ScarabUser user,
                                 Module module, int toOrCC) throws Exception
    {
        if(!isArchiveUser(user))
        {
            fileAddress(userLocaleMap, new InternetAddress(user.getEmail(), 
                user.getName()), chooseLocale(user, module), toOrCC);
        }
        else
        {
            Set<String> archivingMailAddresses = module.getArchivingMailAddresses();
            for(Iterator<String> addresses= archivingMailAddresses.iterator();addresses.hasNext();)
            {
                fileAddress(userLocaleMap, new InternetAddress((String)addresses.next(),
                    user.getName()), chooseLocale(user, module), toOrCC);

            }
        }
    }
            
// in java/org/tigris/scarab/util/Email.java
private static Email getEmail(EmailContext context, Module module,
                                  Object fromUser, Object replyToUser,
                                  String template) throws Exception
    {
        final boolean bSendHtmlMail =
          Turbine.getConfiguration().getBoolean(ScarabConstants.EMAIL_IN_HTML_KEY, true);

        String htmlTemplate = null;
        
        if (context == null)
        {
            context = new EmailContext();
        }

        if (template == null)
        {
            template = Turbine.getConfiguration().getString(
                    "scarab.email.default.template", "Default.vm");
        }
        htmlTemplate = appendTemplateSuffix(template, "Html");
        
        Email te = new Email();
        te.setContext(context);

        setDebug(te); // Activate debug if enabled
        
        setAuth(te); // Activate authentication if configured

        // Set the plain text template
        log.debug("Add plain template ["+template+"]");
        te.setTextTemplate(prependDir(template));
        
        // Set the HTML template
        if (bSendHtmlMail)
        {
            final String templatePath = prependDir(htmlTemplate);
            VelocityEmailService ves = (VelocityEmailService)
                TurbineServices.getInstance().getService(EmailService.SERVICE_NAME);
            if (ves.templateExists(templatePath))
            {
                log.debug("Add HTML template ["+htmlTemplate+"]");
                te.setHtmlTemplate(templatePath);
            }
        }

        EmailLink el = EmailLinkFactory.getInstance(module);
        context.setLinkTool(el);

        String[] nameAndAddr = getNameAndAddress(fromUser);
        te.setFrom(nameAndAddr[1], nameAndAddr[0]);

        nameAndAddr = getNameAndAddress(replyToUser);
        log.debug("Add from name["+nameAndAddr[0]+"], address["+nameAndAddr[1]+"]");
        te.addReplyTo(nameAndAddr[1], nameAndAddr[0]);

        String subjectTemplate = context.getSubjectTemplate();
        /* If we haven't been given a subject template, infer its name from the
         * plain text template name
         * eg IssueActivity.vm -> IssueActivitySubject.vm
         */
        if (subjectTemplate == null)
        {
            subjectTemplate = appendTemplateSuffix(template, "Subject");
        }

        String subjectText = getSubject(context, subjectTemplate);
        log.debug("Add subject ["+subjectText+"]");        
        te.setSubject(subjectText);
        return te;
    }
            
// in java/org/tigris/scarab/util/EmailLink.java
public EmailLink getIssueIdLink(Issue issue)
        throws Exception
    {
        /**
         * The following construction adds the issueId to a local Configuration instance.
         * The so emailConfig will later be used to resolve configuration template which
         * may contain the issueId as property key. See the toString() method for further details.
         */
        CompositeConfiguration compositConfig = new CompositeConfiguration(Turbine.getConfiguration());
        emailConfig = compositConfig;
        Configuration dynamicConfig = new BaseConfiguration();
        compositConfig.addConfiguration(dynamicConfig);
        dynamicConfig.addProperty("issueId", issue.getUniqueId());
        
        this.addPathInfo(ScarabConstants.ID, issue.getUniqueId());
        return this;
    }
            
// in java/org/tigris/scarab/util/EmailLink.java
public EmailLink getServerContext()
        throws Exception
    {
        this.pathInfo.clear();
        isBaseName = true;
        return this;
    }
292 
            
// in java/org/tigris/scarab/pipeline/AnonymousLoginValve.java
catch(Exception e)
                    {
                        // login failed (user unknown, not confirmed, wrong password, ...) no action taken here
                        // Maybe even anonymous login should be forbidden now ?
                        // See below
                    }
            
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
catch (Exception e)
                {
                    LOG.debug("Could not set high buffer size so client may " +
                              "affect timing results.");
                }
            
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
catch (Exception ignore)
                {
                    // maybe this was a binary response?
                    // we still logged it, so ignore
                }
            
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
catch (Exception e)
            {
                LOG.warn(
                    "Could not set locale info for user ["
                        + user.getName()
                        + "]");
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Could not get list attributes", e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
		{
		e.printStackTrace(); throw e; //EXCEPTION
		}
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // Swallow me!
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
                {
                    issueType = new IssueType(defaultIssueTypeId);
                }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
        {
        e.printStackTrace();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
            {
                Log.get().info("[ScarabRequestTool] Unable to retrieve Module: " +
                         key, e);
            }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // system would be messed up, if we are here.  Punt
            nextTemplate = "Index.vm";
            setAlertMessage(L10NKeySet.CannotDetermineIssueEntryTemplate);
            Log.get().error("CannotDetermineIssueEntryTemplate", e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
            {
                setAlertMessage(L10NKeySet.InvalidId);
            }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            setAlertMessage(L10NKeySet.InvalidIssueId);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            valid = false;
            dateField.setMessage("format error ["+e.getMessage()+"]");
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().error("Problem getting user list", e);
            list = new ScarabPaginatedList();
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            hasPermission = false;
            Log.get().error("Permission check failed on:" + permission, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            hasPermission = false;
            Log.get().error("Permission check failed on:" + permission, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            Log.get().debug("Error: ", e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            // Nothing to do. Ignore.
        }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
catch (Exception e)
        {
            // Logged at debug level, as a null user is interpreted
            // as an invalid user name
            Log.get().debug("User, "+username+" could not be found,", e);
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch(Exception e)
        {
            value = createBadResourceValue(key, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch(Exception e)
        {
            value = createBadResourceValue(key, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (Exception e)
        {
            value = createBadResourceValue(key, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (Exception e)
                {
                  // [HD] This should not happen, but it does happen;
                  // The problem raises when the system locale is not
                  // supported by Scarab. This was reported on Windows 
                  // systems. This needs to be further investigated.
                  // setting bundle to null here enforces usage of the
                  // default ResourceBundle (en-US)
                  bundle = null;
                }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
        {
            // return the text as is and log the error
            result = new ArrayList(1);
            result.add(text);
            Log.get().warn("Could not linkify text: " + text, e);
        }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
            {
                Log.get().error(obj + " cannot convert to an integer.", e);
            }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
catch (Exception e)
            {
                e.printStackTrace();
                moduleCodeLength = 4;
            }
            
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
			
		}
            
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
		}
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                key = "";
            }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            return super.toString();
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                throw new TorqueException(e);
            }
            
// in java/org/tigris/scarab/om/MITList.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
        {
            sb.append("Error retrieving list items. see logs.");
            Log.get().warn("", e);
        }
            
// in java/org/tigris/scarab/om/Query.java
catch (Exception e)
                {
                    exception = e;
                }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Activity.java
catch (Exception e)
            {
                getLog().error("Activity.getAttachment(): ", e);
            }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
            {
                getLog().error(e);
                dispVal = "!Error-Check Logs!";
            }
            
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
            {
                getLog().error(e);
                dispVal = "!Error-Check Logs!";
            }
            
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
            
// in java/org/tigris/scarab/om/ROptionOption.java
catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
            
// in java/org/tigris/scarab/om/Condition.java
catch (Exception e) {
            this.getLog().debug("evaluate: Failed to evaluate, will return false. ", e);
        }
            
// in java/org/tigris/scarab/om/Condition.java
catch (Exception e) {
            this.getLog().debug("evaluate: Failed to evaluate, will return empty String. ", e);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                getLog().error("Error getting HTTP_DOMAIN:", e);
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                getLog().error("Error getting DOMAIN_NAME:", e);
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            getLog().error("getCommentRenderingEngine(): " + e);
        }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(Exception e)
                    {
                        // [HD] Compare can not be performed, just ignore it (needs enhancement!!!)
                    }
            
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
            {
                Log.get().warn("Error accessing dedupe sequence for issue "
                               + "type '" + this + '\'', e);
                return sequence;
            }
            
// in java/org/tigris/scarab/om/IssueType.java
catch (Exception e)
        {
            Log.get().warn("Could not get RIA records for " + getName(), e);
        }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch (Exception e) 
            {
                Log.get().error("", e);
                // return null
            }
            
// in java/org/tigris/scarab/om/MITListItem.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
            {
                e.printStackTrace();
                getLog().error(e);
                return null;
            }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e) {
			e.printStackTrace();
			return false;
		}
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            getLog().error("Problem determining whether issue is template");
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            // ignored (return 0 by default)
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            getLog().error(e);
                            e.printStackTrace();
                        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                        {
                            Log.get().error("Unable to retrieve user for "
                                            + "attribute", e);
                        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e)
            {
                getLog().error("An exception prevented retrieving any modules", e);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e){}
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception te)
        {
            getLog().error("getAssignIssuesList(): " + te);
        }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (Exception e) {
    			Log.get().error(e);
			}
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old issues.  "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old reports.  "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            Log.get().warn("Error determining user homepage", e);
        }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().warn("Could not determine query target.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old MIT lists.  "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing old queries.  "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                Log.get().error("Nonfatal error clearing entered issue types. "
                                + "This could be a memory leak.", e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
            {
                final L10NKey msg = new L10NKey("ErrorPossibleMemoryLeak");
                Log.get().warn(msg.getMessage(), e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (Exception e)
        {
            // I think it might be ok to return null from this method
            // but until that is investigated return the default in
            // event of error
            result = ScarabConstants.DEFAULT_LOCALE;
            Log.get().warn(
                "AbstractScarabUser.getLocale() could not "
                    + "retrieve locale for user id="
                    + getUserId()
                    + "; Error message: "
                    + e.getMessage());
        }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            
// in java/org/tigris/scarab/om/AttributePeer.java
catch (Exception e)
                {
                    //
                }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (Exception e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
catch (Exception e)
                {
                    //
                }
            
// in java/org/tigris/scarab/om/AttributeOption.java
catch (Exception e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                    {
                        log.error("queueNotifications(): while processing activity queue: " + e.getMessage(),e);
                        logNotificationData(notification);
                        log.error("queueNotifications(): Abort this run");
                        break;
                    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
        {
            log.error("queueNotifications(): while setting up the activity queue: " + e.getMessage(),e);
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(Exception e)
        {
            log.error("queueNotifications(): while dumping notificationData: " + e.getMessage(),e);
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                    {
                        exception = e;
                        log.error("Failed to send email :" + e);
                    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e)
                {
                    log.error("sendPendingNotifications(): Updating: " + e, e);
                }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
            {
                // [HD] Compare can not be performed, just ignore it (needs enhancement!!!)
            }
            
// in java/org/tigris/scarab/notification/NotificationManagerFactory.java
catch (Exception e)
            {
                log
                        .error("Could not instantiate notification manager '"
                                + classname + "'. Defaulting to '"
                                + ScarabNotificationManager.class.getName()
                                + "': " + e);
                instance = new ScarabNotificationManager();
            }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandlerClient.java
catch (Exception e)
        {
            System.err.println("Error invoking service: " + e);
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (Exception e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("addAttributeOption(String, String) -  : attr=" + attr 
                    + ", opt=" + opt + ", rslt=" + rslt, e);

            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", options=" + options + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandler.java
catch (Exception e) {
            log.error("updateAttributeOption(String, Vector) -  : attr=" + attr 
                    + ", rslt=" + rslt, e);
            
            rslt.add(new Boolean(false));
            rslt.add("Exception : " + e);
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHandlerClient.java
catch (Exception e)
        {
            System.err.println("Error invoking service: " + e);
        }
            
// in java/org/tigris/scarab/screens/ReportExport.java
catch (Exception e)
        {
            printer.print(l10n.get("ErrorOccurredCheckingMessage"));
        }
            
// in java/org/tigris/scarab/screens/SaveTemplate.java
catch (Exception e)
        {
            title = l10n.get("SaveTemplate");
            Log.get().debug("no current issue type, cannot retrieve SaveTemplate title", e);
        }
            
// in java/org/tigris/scarab/screens/ViewIssue.java
catch(Exception e){
			//ignore, this case will be handled later: issue == null
		}
            
// in java/org/tigris/scarab/screens/Default.java
catch (Exception ignore)
        {
        }
            
// in java/org/tigris/scarab/screens/Default.java
catch (Exception e)
            {
                Log.get().info(
                    "Error getting page title for Screen: " + data.getTarget());
            }
            
// in java/org/tigris/scarab/screens/admin/ViewXMLExportIssues.java
catch (Exception e)
                {
                    data.setTarget("admin,XMLExportIssues.vm");
                    scarabR.setAlertMessage(l10n.getMessage(e));
                    return;
                }
            
// in java/org/tigris/scarab/screens/admin/XMLImportIssuesResults.java
catch (Exception e)
                {
                    resultCode = RESULT_ERROR_EXCEPTION;
                    // TODO: Improve localizability of this text.
                    resultString = l10n.get("ProcessingErrors") + ": "
                        + e.getMessage();
                }
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
            
// in java/org/tigris/scarab/screens/ModuleSwitchingLink.java
catch (Exception e)
        {
            Log.get().error("Could not determine homepage", e);
            homePage = "Index.vm";
        }
            
// in java/org/tigris/scarab/screens/MoveIssue.java
catch (Exception e)
        {
            title = "Error; Copy or Move?";
            Log.get().warn("Error determining title", e);
        }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
catch( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/Search.java
catch(Exception e)
                {
                    L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneral,e);
                    scarabR.setAlertMessage(msg);
                }
            
// in java/org/tigris/scarab/actions/Search.java
catch(Exception e)
        {
            // no module selected
            return;
        }
            
// in java/org/tigris/scarab/actions/TemplateList.java
catch (Exception e)
                {
                    success = false;
                    scarabR.setAlertMessage(l10n.getMessage(e));
                }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
                {
                    // would probably be a hack of the form
                    scarabR.setAlertMessage(L10NKeySet.IssueTypeUnavailable);
                    Log.get().debug("", e);
                    return;
                }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.InvalidId);
            Log.get().warn("An invalid id was entered: "+listId);
        }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
            
// in java/org/tigris/scarab/actions/QueryList.java
catch (Exception e)
               {
                   ScarabLocalizationTool l10n = getLocalizationTool(context);
                   getScarabRequestTool(context).setAlertMessage(NO_PERMISSION_MESSAGE);
               }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception e)
        {
            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
            scarabR.setAlertMessage(l10nMessage);
            Log.get().error("Error while checking for duplicates", e);
            setTarget(data, "entry,Wizard1.vm");
            return;
        }
            
// in java/org/tigris/scarab/actions/ReportIssue.java
catch (Exception se)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        return;
                    }
            
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
catch(Exception e)
                        {
                            L10NMessage l10nMessage = new L10NMessage(L10NKeySet.CouldNotSendNotification,e);
                            scarabR.setAlertMessage(l10nMessage);
                        }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (Exception e)
                    {
                        L10NMessage l10nMessage =new L10NMessage(EMAIL_ERROR,e);
                        scarabR.setAlertMessage(l10nMessage);
                    }
            
// in java/org/tigris/scarab/actions/admin/ArtifactTypeEdit.java
catch (Exception e)
                {
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showadduser");
                return;
            }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch(Exception e)
                            {
                                Localizable msg = new L10NMessage(L10NKeySet.ExceptionEmailFailure,e);
                                scarabR.setAlertMessage(msg);
                            }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
            {
                setTarget(data, template);
                data.getParameters().setString("lastAction","");
                Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                scarabR.setAlertMessage (msg);
                Log.get().error(e);
                data.getParameters().setString("state","showedituser");
                return;
            }
            
// in java/org/tigris/scarab/actions/admin/ManageUser.java
catch (Exception e)
        {
            setTarget(data, template);
            data.getParameters().setString("lastAction","");
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
            scarabR.setAlertMessage (msg);
            Log.get().error(e);
            data.getParameters().setString("state","showedituser");
            return;
        }
            
// in java/org/tigris/scarab/actions/admin/ManageArtifactTypes.java
catch (Exception e)
                            {
                                scarabR.setAlertMessage(
                                    l10n.get("CannotDeleteIssueType"));
                                Log.get().warn(
                                    "Could not delete issue type", e);
                            }
            
// in java/org/tigris/scarab/actions/admin/GlobalArtifactTypeCreate.java
catch (Exception e)
               {
                   scarabR.setAlertMessage(l10n.get(NO_PERMISSION_MESSAGE));
               }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
catch (Exception e)
               {
                   scarabR.setAlertMessage(ScarabConstants.NO_PERMISSION_MESSAGE);
               }
            
// in java/org/tigris/scarab/actions/admin/IssueTypeAttributeEdit.java
catch(Exception e)
                {
                    e.printStackTrace();
                }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                        {
                            scarabR.setAlertMessage(
                               l10n.get("RecursiveParentChildRelationship"));
                            intake.remove(pcaoGroup);
                            return false;
                        }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        // on error, reset to previous values
                        intake.remove(pcaoGroup);
                        scarabR.setAlertMessage(l10n.getMessage(se));
                        log().error("", se);
                        return false;
                    }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception e)
                            {
                                log().error("Error adding attribute option:", e);
                                scarabR.setAlertMessage("Error adding attribute option:" + l10n.getMessage(e));
                            }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (Exception se)
                    {
                        intake.remove(newPCAOGroup);
                        scarabR.setAlertMessage(se.getMessage());
                        log().error("", se);
                        return false;
                    }
            
// in java/org/tigris/scarab/actions/admin/ModuleAttributeEdit.java
catch(Exception e)
                {
                    e.printStackTrace();
                }
            
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
catch (Exception e)
        {
            rule.setNew(true);
        }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
catch(Exception e)
                {
                    L10NMessage l10nMessage = new L10NMessage(EMAIL_ERROR,e);
                    scarabR.setAlertMessage(l10nMessage);
                }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception se)
        {
            scarabR.setAlertMessage(l10n.getMessage(se));
        }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
            {
                scarabR.setAlertMessage(ERROR_MESSAGE);
                return;
            }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch(Exception e)
            {
                String l10nMessage = l10n.getMessage(e);
                scarabR.setAlertMessage(l10nMessage);
                return;
            }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    // we do not want any exception thrown here to affect
                    // the user experience, it is just considered a 
                    // non-detectable file type.  But still the exception is
                    // not expected, so log it.
                    mimeAField.setMessage("intake_CouldNotDetermineMimeType");
                    Log.get().info(
                        "Could not determine mimetype of uploaded file.", e);
                }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
        {
            type.setMessage(l10n.get(L10NKeySet.SelectRelation));
            return false;
        }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch(Exception e)
        {
            // Ignore this
        }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
            {
                log().debug("Delete error: ", e);
                return false;
            }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (Exception e)
                {
                    scarabR.setAlertMessage(ERROR_MESSAGE);
                    log().debug("Delete error: ", e);
                }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
            {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
            
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
        {
            scarabR.setAlertMessage(L10NKeySet.SelectModuleAndIssueType);
            return;
        }
            
// in java/org/tigris/scarab/actions/MoveIssue.java
catch (Exception e)
            {
                L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ErrorExceptionMessage,e);
                scarabR.setAlertMessage(l10nMessage);
                Log.get().warn("Exception during issue copy/move", e);
                return;
            }
            
// in java/org/tigris/scarab/reports/ReportHeading.java
catch (Exception e)
                {
                    Log.get().warn("Error on attribute id", e);
                    result = false;
                }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            s = "ERROR! on " + super.toString();
            Log.get().error("", e);
        }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                Log.get().error("Error on Attribute Id=" + attId, e);
                return "Error on Attribute Id=" + attId;
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Attribute Id=" + attId;
                Log.get().error(result, e);
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Attribute Id=" + attId;
                Log.get().error(result, e);
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Option Id=" + optionId;
                Log.get().error(result, e);
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
            {
                result = "Error on Option Id=" + optionId;
                Log.get().error(result, e);
            }
            
// in java/org/tigris/scarab/reports/ReportDefinition.java
catch (Exception e)
        {
            result = "Error on Option Id=" + rua.getUserId();
            Log.get().error(result, e);
        }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
catch (Exception e)
        {
            result = false;
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (Exception e) {
            Log.get().error("filterConditionalTransitions: " + e);
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
            {
                renderingError(filename, e);
            }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            renderingError(filename, e);
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            renderingError(filename, e);
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
            {
                renderingError(filename, e);
            }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception ignored)
            {
            }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch(Exception ex)
        {
            log.error("Double error: Can not dump Email context. ("+ex.getMessage()+")");
            log.error("key["+keystring+"]");
            log.error("val["+val+"]");
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e )
        {
//            Log.error("cannot embed "+surl+": ", e);
        }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/TorqueService.java
catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            Log.get().error(e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/ScarabCache.java
catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
            
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
catch (Exception e) {
				logger.error("Exception caught: ", e);
			}
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/ComponentLocator.java
catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
            {
                LOG.warn("Could not assign nullAttribute", e);
            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotLocateUsername", userStr);
                    importErrors.add(error);
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
        {
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "CouldNotFindGlobalAttribute", activityAttribute);
            importErrors.add(error);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                                  activity.getNewOption(),
                                                  attributeOM.getName(),
                                                  issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption", args);
                                importErrors.add(error);
                                
                                AttributeOptionManager.getInstance(
                                                attributeOM, activity.getNewOption(),
                                                moduleOM, issueTypeOM);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = {
                                        activity.getNewOption(),
                                        attributeOM.getName(),
                                        issueTypeOM.getName()};
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                     getLocale(),
                                     "CouldNotFindModuleAttributeOption",
                                     args);
                                importErrors.add(error);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindAttributeOption",
                                     activity.getOldOption());
                                importErrors.add(error);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                            {
                                final Object[] args = { activity.getOldOption(),
                                                  attributeOM.getName() };
                                final String error = Localization.format
                                    (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                                     "CouldNotFindModuleAttributeOption", args);
                                importErrors.add(error);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
            
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not parse port number", e);
        }
            
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not get scheme parameter", e);
        }
            
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            Log.get().debug("Could not get script name parameter", e);
        }
            
// in java/org/tigris/scarab/util/ScarabLink.java
catch (Exception e)
        {
            allowed = false;
            Log.get().info("Could not check permission due to: ", e);
        }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch (Exception e)
        {
        	
            valid = false;
       
        }
            
// in java/org/tigris/scarab/util/SnippetRenderer.java
catch (Exception e)
        {
            LOG.error("Error rendering " + template + ". ", e);
            result = "ERROR!";
        }
            
// in java/org/tigris/scarab/util/AntServlet.java
catch (Exception ignored)
            {
            }
            
// in java/org/tigris/scarab/util/IssueIdParser.java
catch (Exception e)
        {
            Log.get().error("An npe is going to occur because I could not " +
                            "compile regex: [:alpha:]*\\d+", e);
        }
            
// in java/org/tigris/scarab/util/IssueIdParser.java
catch(Exception e)
            {
                // Ignored on purpose
            }
            
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + className + '\'', e);
            }
            
// in java/org/tigris/scarab/util/EmailLinkFactory.java
catch (Exception e)
            {
                Log.get().warn("Unable to to create '" + linkClass.getName() + 
                               "'; will use default link tool.", e);
                result = new ErrorEmailLink(module);            
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch( Exception e)
        {
            analyzer = new PorterStemAnalyzer();
            Log.get().error("Could not create Lucene Analyzer (" + analyzerClassName + "), using default.", e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/SearchFactory.java
catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
            
// in java/org/tigris/scarab/util/TurbineInitialization.java
catch (Exception e)
        {
            System.err.println("Can't read the properties file (" + 
                configDir + configFile + "). ");
        }
            
// in java/org/tigris/scarab/util/Email.java
catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
            
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
        {
            log.error("Error rendering subject for " + template + ". ", e);
            result = "Scarab System Notification";
        }
            
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
        {
            log.debug("", e);
            // use the basic email
        }
            
// in java/org/tigris/scarab/util/Email.java
catch (Exception e)
            {
                log.error(
                        "Couldn't determine locale for user " + user
                                .getUserName(), e);
            }
            
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
            {
                Log.get().debug(e);
            }
            
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
        {
            Log.get().debug(e);
        }
            
// in java/org/tigris/scarab/util/EmailLink.java
catch (Exception e)
        {
            Log.get().debug(e);
        }
77 
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch(Exception e)
		{
		e.printStackTrace(); throw e; //EXCEPTION
		}
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                throw new TorqueException(e);
            }
            
// in java/org/tigris/scarab/om/MITList.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
            
// in java/org/tigris/scarab/om/ROptionOption.java
catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/MITListItem.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
catch( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch (Exception e)
            {
                throw new Exception("Could not locate module"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
catch(Exception e){
                	if(e instanceof ScarabRuntimeException){
                		scarabR.setAlertMessage(((ScarabRuntimeException)e).getMessage(l10n));  
                		setTarget(data, template);
                		return;
                	}
                	else{
                		throw e; // TODO: don't knwo what to do here.
                	}
                }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
            {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot parse email template", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            dumpContextToLog(e);
            throw new EmailException("Cannot set message body", e);
        }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
catch( Exception e)
        {
            
            dumpContextToLog(e);
            throw new EmailException("Cannot send email template", e);
        }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/TorqueService.java
catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/ScarabCache.java
catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("getGroups(Criteria) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            throw new DataBackendException("addGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/ComponentLocator.java
catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssuesTask.java
catch (Exception e)
        {
            throw new BuildException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/SearchFactory.java
catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
27
unknown (Lib) FeedException 0 0 1 
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
public SyndFeed getFeed() throws IOException, FeedException, TorqueException, Exception {

        SyndFeed feed = new SyndFeedImpl();
       
        String title = issue.getUniqueId() + ": " + issue.getDefaultText();
        feed.setTitle(title);
        String link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
        feed.setLink(link);
        feed.setDescription(title);

        List entries = new ArrayList();
        List allActivities = issue.getActivity(true);
        

        for (Iterator i = allActivities.iterator(); i.hasNext();) {
            SyndEntry entry;
            SyndContent description;
            
            Activity activity = (Activity)i.next();
            
            ActivitySet activitySet = activity.getActivitySet();
            Date date =activitySet.getCreatedDate();
            entry = new SyndEntryImpl();

            entry.setPublishedDate(date);
            
            description = new SyndContentImpl();
            description.setType("text/html");
            
            String desc =
                  "<b>Description:</b>" + activity.getDisplayName(this.l10nTool) +"<br/>"
                + "<b>New:</b>" + activity.getNewValue(this.l10nTool) +"<br/>"
                + "<b>Old:</b>" + activity.getOldValue(this.l10nTool) +"<br/>"
                + "<b>Reason:</b>" + activitySet.getCommentForHistory(issue) +"<br/>";
            
            entry.setAuthor(activitySet.getCreator().getName());

            description.setValue(desc.toString());            

			String entryTitle = createEntryTitle(activity);
            entry.setTitle(entryTitle);
            
            entry.setDescription(description);
            
            //The hashCode is a cheap trick to have a unique link tag in the RSS feed
            //to help those reader as ThunderBird that use the link to check for new items
            entry.setLink(link+"?hash="+entry.hashCode());
            
            entries.add(entry);
        }
     

        feed.setEntries(entries);
        
        return feed;
    }
1 
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
0 0
unknown (Lib) FileNotFoundException 0 0 2 
            
// in java/org/tigris/scarab/om/Attachment.java
public void copyFileTo(final String path)
        throws TorqueException, ScarabException, FileNotFoundException, IOException
    {
        copyFileFromTo(getFullPath(), path);
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public void copyFileFromTo(final String from, final String path)
        throws FileNotFoundException, IOException
    {
        BufferedInputStream in = null;
        BufferedOutputStream out = null;
        try
        {
            File f = new File(path);
            if (!f.getParentFile().exists()) 
            {
                f.getParentFile().mkdirs();
            }
            
            in = new BufferedInputStream(new FileInputStream(from));
            out = new BufferedOutputStream(new FileOutputStream(f));
            final byte[] bytes = new byte[2048];
            int nbrRead = 0;
            while ((nbrRead = in.read(bytes)) != -1)
            {
                out.write(bytes, 0, nbrRead);
            }
        }
        finally
        {
            try
            {
                in.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            try
            {
                out.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
        }
    }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
0
checked (Lib) IOException 0 0 35 
            
// in java/org/tigris/scarab/pipeline/ResetCacheValve.java
public final void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // clear the short-term cache
        ScarabCache.clear();

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/AnonymousLoginValve.java
public void invoke(RunData data, ValveContext context) throws IOException, TurbineException
    {
        String target = data.getTarget();
        
        // Only try this if accessing an authenticated page:
        if (!nonAnonymousTargets.contains(target) && target.indexOf("help,") == -1)
        {
            ScarabUser user = (ScarabUser)data.getUserFromSession();
            // If there's no user, we will try login:

            if (null == user || user.getUserId() == null || !user.hasLoggedIn())
            {
                boolean isLoggedIn = false;
                String username   = data.getParameters().get("userid");
                // Maybe a User has been provided in the parameter list ?    
                if(username != null)
                {
                    String password = data.getParameters().get("password");
                    final ScarabRequestTool scarabR = null;
                    try
                    {
                        // Try logging in. Note No ScarabRequestTool available here,
                        // so no screen action can be prepared here.
                        isLoggedIn = Login.authentifyWithCredentials(data, scarabR, username, password);
                    }
                    catch(Exception e)
                    {
                        // login failed (user unknown, not confirmed, wrong password, ...) no action taken here
                        // Maybe even anonymous login should be forbidden now ?
                        // See below
                    }
                }

                // We were not able to log in an authenticated user (as possibly tried above) but anonymous login is enabled
                if(!isLoggedIn && anonymousAccessAllowed)
                {
                    // So perform anonymous login here
                    Login.anonymousLogin(data);
                }
                
            }
        }
        context.invokeNext(data);        
    }
            
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve22.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // if we are forcing a particular charset, use it.  Hopefully
        // client has encoded for this default. This is the same 
        // property that will force the charset in our responses.
        String encoding = REQUIRED_CHARSET;   

        if (encoding == null) 
        {
            // guess the charset from the client's headers
            encoding = ComponentLocator.getMimeTypeService().getCharSet(data.getLocale());
        }

        // if the charset was specified in the configuration or the charset
        // map contained a value for the locale, set it, otherwise leave
        // it as the servlet engine has set it.
        if (encoding != null) 
        {
            // data.getRequest().setCharacterEncoding(encoding);
            data.setCharSet(encoding);
        }
        
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/DetermineTargetValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ParameterParser parameters = data.getParameters();
        if (! data.hasTarget())
        {
            String target = parameters.getString("template");
            String query  = parameters.getString("query");
            if(query==null)
            {
                query = parameters.getString("queryId");
            }

            if (query != null && getEventKey(parameters)==null)
            {
                parameters.setString("eventSubmit_doSelectquery", "foo");
                // Allows short link to public/personal queries
                // $scarabRoot/issues/query/<queryId>/curmodule/<moduleId>                
                if (target == null) target="IssueList.vm";
                data.setTarget(target);
                if (parameters.getString("tqk")      == null) parameters.setString("tqk", ""+0);
                if (parameters.getString("action")   == null) data.setAction("Search");
                if (parameters.getString("go")       == null) parameters.setString("go",query);
            }
            else if (target != null)
            {
                data.setTarget(target);
                Log.get().debug("Set target from request parameter");
            }
            else if (parameters.getString("id") != null)
            {
                // Allows short link to issue
                // $scarabRoot/issues/id/<issueId>
                data.setTarget("ViewIssue.vm");
            }
            else
            {
                //data.getResponse().sendError(404);
                //return;
                ScarabUser user = (ScarabUser)data.getUserFromSession();
                if(user!= null && user.getUserId() != null && user.getUserId().longValue() > 0)
                {
                    ScarabRequestTool scarabR = ((ScarabRequestTool)Module.getTemplateContext(data)
                            .get(ScarabConstants.SCARAB_REQUEST_TOOL));
                    org.tigris.scarab.om.Module module = scarabR.getCurrentModule();
                    
                    try
                    {
                        if(module != null)
                        {
                            target = user.getHomePage(module);
                        }
                        else
                        {
                            target = user.getHomePage();
                        }
                    }
                    catch (TorqueException e)
                    {
                        target = null;
                    }
                }
                if(target == null)
                {
                    target = Turbine.getConfiguration().getString(
                            Turbine.TEMPLATE_HOMEPAGE);                    
                }
                data.setTarget(target);
                Log.get().debug("Set target to ["+target+"]");

            }
        }
        
        if (Log.get().isDebugEnabled())
        {
            Log.get().debug("Target is now: " + data.getTarget());
        }

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // if we are forcing a particular charset, use it.  Hopefully
        // client has encoded for this default. This is the same 
        // property that will force the charset in our responses.
        String encoding = REQUIRED_CHARSET;   

        if (encoding == null) 
        {
            // guess the charset from the client's headers
            encoding = ComponentLocator.getMimeTypeService().getCharSet(data.getLocale());
        }

        // if the charset was specified in the configuration or the charset
        // map contained a value for the locale, set it, otherwise leave
        // it as the servlet engine has set it.
        if (encoding != null) 
        {
            data.getRequest().setCharacterEncoding(encoding);
            data.setCharSet(encoding);
        }
        
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        if (DEBUG) 
        {
            Long start = (Long)data.getRequest().getAttribute(KEY);
            if (start == null) 
            {
                try 
                {
                    data.getResponse().setBufferSize(10000000);
                }
                catch (Exception e)
                {
                    LOG.debug("Could not set high buffer size so client may " +
                              "affect timing results.");
                }
                ((ScarabRequestTool)Module.getTemplateContext(data)
                    .get("scarabR")).startTimer();
                data.getRequest()
                    .setAttribute(KEY, new Long(System.currentTimeMillis()));
            }
            else
            {
                String s = "Action=" + data.getAction() + " and template=" + 
                    data.getTarget() + " took: " + 
                    (System.currentTimeMillis() - start.longValue()) + " ms";
                LOG.debug(s);
                try 
                {
                    data.getResponse().getWriter().println(s);        
                }
                catch (Exception ignore)
                {
                    // maybe this was a binary response?
                    // we still logged it, so ignore
                }
            }
        }
            
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ScarabUser user = (ScarabUser) data.getUser();

        // Ensure we only deal with exsiting users
        if (user != null && user.getUserId() != null)
        {
            try
            {
                String acceptLanguage = LocalizationService.ACCEPT_LANGUAGE;
                HttpServletRequest request = data.getRequest();
                String browserLocaleAsString =
                    request.getHeader(acceptLanguage);

                Locale userLocale = user.getLocale();
                Locale browserLocale =
                    Localization.getLocale(browserLocaleAsString);

                if (!userLocale.equals(browserLocale))
                {
                    storePreferredLocale(user, browserLocaleAsString);
                }
            }
            catch (Exception e)
            {
                LOG.warn(
                    "Could not set locale info for user ["
                        + user.getName()
                        + "]");
            }
        }
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        
        try
        {
            // Check, whether password is expired 
            if(user.isPasswordExpired())
            {
                // Under no conditions an expired password will be
                // accepted. The request is always forwarded to the
                // password change mask until the password has been reset. [HD]
                data.setTarget("ChangePassword.vm");
                data.save();
                context.invokeNext(data);
                return;
            }
            adjustCurrentModule(user, data);
            adjustCurrentIssueType(user, data);
        }
        catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }

        // set the thread key 
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.THREAD_QUERY_KEY);
        if (key != null) 
        {
            user.setThreadKey(new Integer(key));
        }
        else
        {
            user.setThreadKey(null);
        }
        
        // remove any report that was aborted
        String reportKey = parameters.getString(ScarabConstants.REMOVE_CURRENT_REPORT);
        if (reportKey != null && reportKey.length() > 0)
        {
            user.setCurrentReport(reportKey, null);
        }

        // remove the current module/issuetype list, if needed
        String removeMitKey = 
            parameters.getString(ScarabConstants.REMOVE_CURRENT_MITLIST_QKEY);
        String target = data.getTarget();
        boolean xmitScreen =XMIT_SCREENS.containsKey(target); 
        if (removeMitKey != null 
            || !xmitScreen)
        {
            Log.get().debug("xmit list set to null");
            user.setCurrentMITList(null);
        }

        // override the current module/issuetype list if one is given
        // in the url.
        String mitid = parameters.getString(ScarabConstants.CURRENT_MITLIST_ID);
        if (mitid != null) 
        {
            MITList mitList = null;
            try
            {
                // FIXME: no getInstance(Integer)
                mitList = MITListManager.getInstance(new NumberKey(mitid));
                user.setCurrentMITList(mitList);
                mitList.setScarabUser(user);
            }
            catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
public void invoke(RunData data, ValveContext context) throws IOException, TurbineException
    {
        try
        {
    	   if (bNTLMActive &&
                   (
                   ((null == data.getUserFromSession() || data.getUserFromSession().getUserName().trim().length()==0) && null == data.getUser())
                   || ((ScarabUser)data.getUserFromSession()).isUserAnonymous()
                   )
                   && ( !data.getAction().equals("Logout")
                           && !data.getAction().equals("Login")
                           && !data.getTarget().equals("Register.vm")
                           && !data.getTarget().equals("ForgotPassword.vm")
                    ))
            {
                authenticateNtlm(data);
            }
        }
        catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
    	   context.invokeNext(data);       
    }
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
private void authenticateNtlm(RunData data) throws IOException
    {
        HttpServletRequest request = data.getRequest();
        HttpServletResponse response=data.getResponse();
        UniAddress dc;
        String msg = request.getHeader("Authorization");
        if (msg != null && msg.startsWith("NTLM "))
        {
            dc = UniAddress.getByName(domainController, true);
            NtlmPasswordAuthentication ntlm = null;
            if (msg.startsWith("NTLM "))
            {
                byte[] challenge = SmbSession.getChallenge(dc);
                try
                {
                    ntlm = NtlmSsp.authenticate(request, response, challenge);
                }
                catch (IOException e)
                {
                    log.error("authenticateNtlm: " + e);
                }
                catch (ServletException e)
                {
                    log.error("authenticateNtlm: " + e);
                }
                if (ntlm == null)
                    return;
            }
            else
            {
                String auth = new String(Base64.decode(msg.substring(6)),
                        "US-ASCII");
                int index = auth.indexOf(':');
                String user = (index != -1) ? auth.substring(0, index) : auth;
                String password = (index != -1) ? auth.substring(index + 1)
                        : "";
                index = user.indexOf('\\');
                if (index == -1)
                    index = user.indexOf('/');
                String domain = (index != -1) ? user.substring(0, index)
                        : domainController;
                user = (index != -1) ? user.substring(index + 1) : user;
                ntlm = new NtlmPasswordAuthentication(domain, user, password);
            }
            try
            {
                SmbSession.logon(dc, ntlm);
            }
            catch (SmbAuthException sae)
            {
                response.setHeader("WWW-Authenticate", "NTLM");
                response.setHeader("Connection", "close");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.flushBuffer();
                return;
            }
            
            try
            {
                // Once the user has been authenticated, we'll try logging in Scarab.
                String creds[] = {ntlm.getUsername(), domainController};
                ScarabUser user = (ScarabUser)TurbineSecurity.getUser(creds[0]);
                
                if(user != null && user.isConfirmed())
                {
                	Login.simpleLogin(data, user);
                	
                	//Inform the user that s/he's been logged in using NTLM credentials!
                    L10NMessage mesg = new L10NMessage(L10NKeySet.AutomaticallyLoggedIn, creds);
                    ScarabLocalizationTool l10n = new ScarabLocalizationTool();
                    l10n.init(user.getLocale());
                    data.setMessage(mesg.getMessage(l10n));
                }
                data.setTarget("SelectModule.vm");
            }
            catch (DataBackendException e)
            {
                log.error("authenticateNtlm: " + e);
            }
            catch (UnknownEntityException e)
            {
                log.error("authenticateNtlm: " + e);
            }
        }
        else
        {
            HttpSession ssn = request.getSession(false);
            if (ssn == null || ssn.getAttribute("NtlmHttpAuth") == null)
            {
                response.setHeader("WWW-Authenticate", "NTLM");
                // TODO: Allow a maximum number of connection attempts?
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.flushBuffer();
                return;
            }
        }
    }
            
// in java/org/tigris/scarab/pipeline/SetInfoMessageValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ((ScarabRequestTool)Module.getTemplateContext(data)
            .get(ScarabConstants.SCARAB_REQUEST_TOOL)).setInfoMessage(message);

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		System.out.println("User dir:" + System.getProperty("user.dir"));
		System.out.println("Now reading project.properties");
		Properties properties = new Properties();
	    try {
	        properties.load(new FileInputStream("../../project.properties"));
	    } catch (IOException e) {
	    	e.printStackTrace();
	    }

	    try {
	        properties.load(new FileInputStream("../../build.properties"));
	    } catch (IOException e) {
	    	System.out.println("There is probably no build.properties file.");
	    }
	    
	    // Init HTTP scheme information
	    // Since the installer runs in the same container as the Scarab to
	    // be built, getting these informations from the request probably
	    // makes more sense than the default values.
	    properties.setProperty("scarab.http.scheme", request.getScheme());
	    properties.setProperty("scarab.http.domain", request.getServerName());
	    properties.setProperty("scarab.http.port", new Integer(request.getServerPort()).toString());
	    
	    // Init additional properties for the database generation.
	    properties.setProperty("skip.seed.data", "false");
	    properties.setProperty("skip.jira.templates.data", "false");
	    
	    request.getSession().setAttribute("properties", properties);
	    
		response.sendRedirect(response.encodeRedirectURL("BasicSettings.jsp"));
	}
            
// in java/org/tigris/scarab/tools/install/web/SaveSettingsServlet.java
public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		String redirect = null;
		Properties properties = (Properties) request.getSession().getAttribute("properties");
		
		Map parameterMap = request.getParameterMap( );
		if (parameterMap == null)
	        throw new ServletException("getParameterMap returned null in: " + getClass( ).getName( ));

		Iterator iterator = parameterMap.entrySet( ).iterator( );
		while(iterator.hasNext( )){
			Map.Entry me = (Map.Entry)iterator.next( );
			String key = (String) me.getKey();
			String[] arr = (String[]) me.getValue( );
			String value = arr[0];
			System.out.println("Key: [" + key + "] Value: [" + value + "]");

			if ("redirect".equals(me.getKey())) {
				redirect = value;
			}

			if (key.indexOf('.') != -1) {
				properties.setProperty(key, value);
			}
		}

		if (redirect == null) {
			System.out.println("ERROR: no redirect specified, redirect to BasicSettings.jsp");
		}
		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL(redirect));
	}
            
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		PrintWriter out = response.getWriter();
		
		try {
			ResourceBundle rb = ResourceBundle.getBundle("InstallBundle");

			File currentDirectory = new File(System.getProperty("user.dir"));
			String buildDirectoryName = currentDirectory.getParentFile().getParentFile().getAbsolutePath() + File.separatorChar + "build";
			String commandLine1 = null;
			
			// Write a couple of batch (command) file
			// I could not find another way to launch ant in another directory
			if ("Windows".equals(System.getProperty("os.name").substring(0, 7))) {
		        BufferedWriter batch1 = new BufferedWriter(new FileWriter("build-scarab.cmd"));
		        batch1.write("cd " + buildDirectoryName + "\r\n");
		        batch1.write("ant\r\n");
		        batch1.close();
		        
		        commandLine1 = "cmd /c build-scarab.cmd";
			} else {
		        BufferedWriter batch1 = new BufferedWriter(new FileWriter("build-scarab"));
		        batch1.write("#! /bin/sh\n");
		        batch1.write("cd " + buildDirectoryName + "\n");
		        batch1.write("ant\n");
		        batch1.close();
		        
		        commandLine1 = "sh ./build-scarab";
			}

			// Launch first batch to build Scarab
			out.println("<div class=\"infomessage\">");
			out.println("<strong>Phase 1</strong> : " + rb.getString("building.scarab.application"));
			out.println("</div>");
			
			Process child = Runtime.getRuntime().exec(commandLine1);
			
			out.println("<pre>");
			InputStream in = child.getInputStream();
			int c;
			while ((c = in.read()) != -1) {
				out.print((char) c);
			}
			out.println("</pre>");
			in.close();
			
			if (child.exitValue() == 0) {
				out.println("<p class=\"infomark\">" + rb.getString("success") + "</p>");
			} else {
				out.println("<p class=\"errormark\">" + rb.getString("failure") + "</p>");
			}
		} catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		} catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
			
		}
		
	}
            
// in java/org/tigris/scarab/tools/install/web/Build1Servlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		Properties properties = (Properties) request.getSession().getAttribute("properties");
		System.out.println("Now writing the build.properties file.");
		properties.store(new FileOutputStream("../../build.properties"), "Generated by ScarabWebInstaller");
		System.out.println("Done.");
		
		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL("Build1.jsp"));

	}
            
// in java/org/tigris/scarab/tools/install/web/Build2Servlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL("Build2.jsp"));

	}
            
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		PrintWriter out = response.getWriter();
		

		try {
			ResourceBundle rb = ResourceBundle.getBundle("InstallBundle");

			File currentDirectory = new File(System.getProperty("user.dir"));
			String buildDirectoryName = currentDirectory.getParentFile().getParentFile().getAbsolutePath() + File.separatorChar + "build";
			String commandLine2 = null;
			
			// Write a couple of batch (command) file
			// I could not find another way to launch ant in another directory
			if ("Windows".equals(System.getProperty("os.name").substring(0, 7))) {
		        BufferedWriter batch2 = new BufferedWriter(new FileWriter("build-scarab-db.cmd"));
		        batch2.write("cd " + buildDirectoryName + "\r\n");
		        batch2.write("ant create-db\r\n");
		        batch2.close();
		        
		        commandLine2 = "cmd /c build-scarab-db.cmd";
			} else {
		        BufferedWriter batch2 = new BufferedWriter(new FileWriter("build-scarab-db"));
		        batch2.write("#! /bin/sh\n");
		        batch2.write("cd " + buildDirectoryName + "\n");
		        batch2.write("ant\n");
		        batch2.close();
		        
		        commandLine2 = "sh ./build-scarab-db";
			}

			// Launch second batch to build the Scarab database
			out.println("<div class=\"infomessage\">");
			out.println("<strong>Phase 2</strong> : " + rb.getString("building.scarab.database"));
			out.println("</div>");
			
			Process child = Runtime.getRuntime().exec(commandLine2);
			
			out.println("<pre>");
			InputStream in = child.getInputStream();
			int c;
			while ((c = in.read()) != -1) {
				out.print((char) c);
			}
			out.println("</pre>");
			in.close();
			
			if (child.exitValue() == 0) {
				out.println("<p class=\"infomark\">" + rb.getString("success") + "</p>");
			} else {
				out.println("<p class=\"errormark\">" + rb.getString("failure") + "</p>");
			}
		} catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		} catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
		}
		
	}
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
private void readObject(java.io.ObjectInputStream in)
         throws java.io.IOException, ClassNotFoundException
    {
        try
        {
            in.defaultReadObject();
        }
        catch (java.io.NotActiveException e)
        {
        }
        initThreadLocals();
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public void copyFileTo(final String path)
        throws TorqueException, ScarabException, FileNotFoundException, IOException
    {
        copyFileFromTo(getFullPath(), path);
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public void copyFileFromTo(final String from, final String path)
        throws FileNotFoundException, IOException
    {
        BufferedInputStream in = null;
        BufferedOutputStream out = null;
        try
        {
            File f = new File(path);
            if (!f.getParentFile().exists()) 
            {
                f.getParentFile().mkdirs();
            }
            
            in = new BufferedInputStream(new FileInputStream(from));
            out = new BufferedOutputStream(new FileOutputStream(f));
            final byte[] bytes = new byte[2048];
            int nbrRead = 0;
            while ((nbrRead = in.read(bytes)) != -1)
            {
                out.write(bytes, 0, nbrRead);
            }
        }
        finally
        {
            try
            {
                in.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            try
            {
                out.close();
            }
            catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
        }
    }
            
// in java/org/tigris/scarab/screens/DataExport.java
protected Writer getWriter(RunData data)
        throws IOException
    {
        Writer writer = null;
        String encoding = getEncodingForExport(data);
        if (encoding != null && !encoding.equals(""))
        {
            writer =
                new OutputStreamWriter(data.getResponse().getOutputStream(),
                                       encoding);
        }
        else
        {
            writer = data.getResponse().getWriter();
        }
        return writer;
    }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
public SyndFeed getFeed() throws IOException, FeedException, TorqueException, Exception {

        SyndFeed feed = new SyndFeedImpl();
       
        String title = issue.getUniqueId() + ": " + issue.getDefaultText();
        feed.setTitle(title);
        String link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
        feed.setLink(link);
        feed.setDescription(title);

        List entries = new ArrayList();
        List allActivities = issue.getActivity(true);
        

        for (Iterator i = allActivities.iterator(); i.hasNext();) {
            SyndEntry entry;
            SyndContent description;
            
            Activity activity = (Activity)i.next();
            
            ActivitySet activitySet = activity.getActivitySet();
            Date date =activitySet.getCreatedDate();
            entry = new SyndEntryImpl();

            entry.setPublishedDate(date);
            
            description = new SyndContentImpl();
            description.setType("text/html");
            
            String desc =
                  "<b>Description:</b>" + activity.getDisplayName(this.l10nTool) +"<br/>"
                + "<b>New:</b>" + activity.getNewValue(this.l10nTool) +"<br/>"
                + "<b>Old:</b>" + activity.getOldValue(this.l10nTool) +"<br/>"
                + "<b>Reason:</b>" + activitySet.getCommentForHistory(issue) +"<br/>";
            
            entry.setAuthor(activitySet.getCreator().getName());

            description.setValue(desc.toString());            

			String entryTitle = createEntryTitle(activity);
            entry.setTitle(entryTitle);
            
            entry.setDescription(description);
            
            //The hashCode is a cheap trick to have a unique link tag in the RSS feed
            //to help those reader as ThunderBird that use the link to check for new items
            entry.setLink(link+"?hash="+entry.hashCode());
            
            entries.add(entry);
        }
     

        feed.setEntries(entries);
        
        return feed;
    }
            
// in java/org/tigris/scarab/services/security/ldap/DummyCallbackHandler.java
public void handle(Callback[] callbacks) throws IOException,
			UnsupportedCallbackException {
		for (int i = 0; i < callbacks.length; i++) {
			if (callbacks[i] instanceof NameCallback) {
				((NameCallback) callbacks[i]).setName(username);
			} else if (callbacks[i] instanceof PasswordCallback) {
				((PasswordCallback) callbacks[i]).setPassword(password);
            } else if (callbacks[i] instanceof LDAPUserInfoCallback) {
                ldapUserInfo = (LDAPUserInfoCallback) callbacks[i];
			} else {
				throw new UnsupportedCallbackException(callbacks[i],
						"Callback class not supported");
			}
		}
	}
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public void init()
        throws ScarabException,MalformedURLException,IOException
    {
        TurbineInitialization.setTurbineResources(getTurbineResources());
        TurbineInitialization.setUp(getConfigDir().getAbsolutePath(), 
            getConfigFile());
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader readerFor(Object input)
        throws IOException
    {
        if (input instanceof FileItem)
        {
            return new InputStreamReader(((FileItem) input).getInputStream());
        }
        else if (input instanceof File)
        {
            return new BufferedReader(new FileReader((File) input));
        }
        else
        {
            throw new IllegalArgumentException(); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected void validate(final String name, 
            final Reader is,
            final BeanReader reader, 
            final Module currentModule)
        throws ParserConfigurationException,SAXException,IOException
    {
        // While parsing the XML, we perform well formed-ness and DTD
        // validation (if present, see Xerces dynamic feature).
        setValidationMode(reader, true);
        ScarabIssues si = null;
        try
        {
            si = (ScarabIssues) reader.parse(is);
        }
        catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }

        // If the XML is okay, validate the actual content.
        if (si != null)
        {
            // ASSUMPTION: Parse errors prevent entry into this block.
            validateContent(si, currentModule);

            // Log any errors encountered during import.
            if (importErrors != null)
            {
                final int nbrErrors = importErrors.size();
                LOG.error("Found " + nbrErrors + " error" +
                          (nbrErrors == 1 ? "" : "s") + " importing '" +
                          name + "':");
                for (Iterator itr = importErrors.iterator(); itr.hasNext(); )
                {
                    LOG.error(itr.next());
                }
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected ScarabIssues insert(
            final String name, 
            final Reader is, 
            final BeanReader reader)
        throws ParserConfigurationException,SAXException,IOException,ScarabException, TorqueException
    {
        setValidationMode(reader, false);
        final ScarabIssues si = (ScarabIssues)reader.parse(is);
        si.doHandleDependencies();
        LOG.debug("Successfully imported " + name + '!');
        return si;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected void write(final Object bean, final Writer out)
        throws IOException,SAXException,IntrospectionException
    {
        final BeanWriter writer = new BeanWriter(out);
        writer.setXMLIntrospector(createXMLIntrospector());
        writer.enablePrettyPrint();
        writer.setWriteIDs(false);
        writer.write(bean);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader getScarabFormattedReader(
            final Object input,
            final ImportType type,
            final Module currModule) throws IOException, TransformerException, TorqueException, JDOMException 
    {
        Reader returnValue = null;
        
        if( SCARAB == type )
        {
            // is in correct format already, just return the input stream
            returnValue = readerFor(input);
        }
        else if( BUGZILLA == type )
        {
            // Location of the extensions directory for Bugzilla
            // Transform configuration, mappings and attachments are here
            // TODO move onto resourceDirectory derivative
            final String extensions = System.getProperty("catalina.home") + "/../extensions/bugzilla";
            
            // Locate the Bugzilla to Scarab XSL transform
            final InputStream xsl = getClass().getResourceAsStream(BUGZILLA_XSL);
            
            // Transform Bugzilla xml to scarab format
            // (Trailing '/' to resources is deliberate)
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, extensions);
            
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        else if( JIRA == type )
        {
                    
            // transform xml to scarab format
            final InputStream xsl = getClass().getResourceAsStream(JIRA_XSL);
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, resourceDirectory);
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        return returnValue;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader insertModuleNode(final Reader result, 
            final Module currModule) 
        throws TorqueException, JDOMException, IOException, TransformerException 
    {
        
        final ScarabUser user = ScarabUserManager.getInstance(currModule.getOwnerId());        
        
        // Core Java: org.w3c.dom version (jdk1.4+ compatible)
//        final DocumentBuilder docBuilder = documentBuilderFactory.newDocumentBuilder();
//        final Document doc = docBuilder.parse( new InputSource(result) );
//        // insert module
//        final Element root = doc.getDocumentElement();
//        final Element moduleNode = doc.createElement("module");
//        final Element idNode = doc.createElement("id");
//        final Element parentIdNode = doc.createElement("parent-id");
//        final Element nameNode = doc.createElement("name");
//        final Element ownerNode = doc.createElement("owner");
//        final Element descriptionNode = doc.createElement("description");
//        final Element urlNode = doc.createElement("url");
//        final Element domainNode = doc.createElement("domain");
//        final Element codeNode = doc.createElement("code");
//        
//        idNode.appendChild(doc.createTextNode(String.valueOf(currModule.getModuleId())));
//        parentIdNode.appendChild(doc.createTextNode(String.valueOf(currModule.getParentId())));
//        nameNode.appendChild(doc.createTextNode(currModule.getName()));
//        ownerNode.appendChild(doc.createTextNode(user.getUserName()));
//        descriptionNode.appendChild(doc.createTextNode(currModule.getDescription()));
//        urlNode.appendChild(doc.createTextNode(currModule.getUrl()));
//        domainNode.appendChild(doc.createTextNode(currModule.getHttpDomain()));
//        codeNode.appendChild(doc.createTextNode(currModule.getCode()));
//        
//        moduleNode.appendChild(idNode);
//        moduleNode.appendChild(parentIdNode);
//        moduleNode.appendChild(nameNode);
//        moduleNode.appendChild(ownerNode);
//        moduleNode.appendChild(descriptionNode);
//        moduleNode.appendChild(urlNode);
//        moduleNode.appendChild(domainNode);
//        moduleNode.appendChild(codeNode);
//        
//        root.appendChild(moduleNode);
        
        // JDom version (jdk1.3 compatible)
        
        final SAXBuilder builder = new SAXBuilder();
        builder.setEntityResolver(new EntityResolver()
        {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }   
        });
        final Document doc = builder.build(result);        
        final Element root = doc.getRootElement();

        final Element moduleNode = new Element("module");
        final Element idNode = new Element("id");
        final Element parentIdNode = new Element("parent-id");
        final Element nameNode = new Element("name");
        final Element ownerNode = new Element("owner");
        final Element descriptionNode = new Element("description");
        final Element urlNode = new Element("url");
        final Element domainNode = new Element("domain");
        final Element codeNode = new Element("code");    
        
        idNode.setText(String.valueOf(currModule.getModuleId()));
        parentIdNode.setText(String.valueOf(currModule.getParentId()));
        nameNode.setText(currModule.getRealName());
        ownerNode.setText(user.getUserName());
        descriptionNode.setText(currModule.getDescription());
        urlNode.setText(currModule.getUrl());
        domainNode.setText(currModule.getHttpDomain());
        codeNode.setText(currModule.getCode());
        
        moduleNode.addContent(idNode)
                .addContent(parentIdNode)
                .addContent(nameNode)
                .addContent(ownerNode)
                .addContent(descriptionNode)
                /*
                 * These are excluded for now, since your database domain may 
                 * not correspond to currModule.getHttpDomain().
                .addContent(urlNode)
                .addContent(domainNode)
                 */
                .addContent(codeNode);
        root.addContent(2,moduleNode);
        
        return transformXML(new JDOMSource(doc), null, currModule, null);
    }
            
// in java/org/tigris/scarab/util/AntServlet.java
public final void doGet (HttpServletRequest req, HttpServletResponse res)
        throws IOException               
    {
        res.setContentType("text/html");

        /* Retrieve some parameters.
         * Refresh = the value of refresh tag in seconds.
         * target = the name of the target to execute with ant.
         */        
        String refresh = req.getParameter("refresh");
        String target =  req.getParameter("target");
        
        if (target == null)
        {
            target = new String("");
        }

        /*
         * Write output to the client..
         */
        PrintWriter out = res.getWriter();
        try
        {
            out.println("<html>");
            out.println("<head>");
            out.println("<title>Ant Servlet</title>");
            
            // write the refresh tag if necessary 
            if (refresh != null)
            {
                out.println("<meta http-equiv=Refresh content=" + refresh + "/>");
            }
    
            out.println("</head>");
            out.println("<body bgcolor=\"white\">");
            out.println("<hr size=\"1\" noshade=\"true\">");
            out.flush();

            // do the ant command..
            Runtime runtime = Runtime.getRuntime();
    
            int returnValue = 0;
            BufferedReader in = null;
            try
            {
                Process pro = runtime.exec(buildCommand + " " + buildFile + 
                    " " + target);
                in = new BufferedReader(
                                       new InputStreamReader(
                                           pro.getInputStream()));
                String inline = null;
                out.println("<pre>");
                while((inline = in.readLine()) != null)
                {
                    out.println(inline);
                    out.flush();
                }
                out.println("</pre>");
                out.flush();
                returnValue = pro.waitFor();
                
            }
            catch (Exception ignored)
            {
            }
            finally
            {
                if (in != null)
                {
                    in.close();
                }
            }
    
            out.println("<hr size=\"1\" noshade=\"true\">");
            out.println("Return value from Ant:" + returnValue);
            out.println("</body>");
            out.println("</html>");
            out.flush();
        }
        finally
        {
            if (out != null)
            {
                out.close();
            }
        }
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private void flush() throws CorruptIndexException, IOException
    {
        writer.flush();
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private void optimize(boolean immediately) throws CorruptIndexException, IOException
    {
        if(immediately || updateCounter  % 100 == 0)
        {
            writer.optimize();
        }
        updateCounter++;
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private void close() throws CorruptIndexException, IOException
    {
        writer.close();
    }
            
// in java/org/tigris/scarab/util/TurbineInitialization.java
public static void setUp(final String configDir, final String configFile)
        throws ScarabException,MalformedURLException,IOException
    {
        if (configDir == null || configFile == null)
        {
            System.err.println("config.dir System property was not defined");
            throw new ScarabException (new L10NKey("configDir or configFile was null")); // FIXME localise
        }

        // set this so that the proper substitution will happen in the
        // configFile
        System.getProperties().setProperty("configDir", configDir);

        initTurbine(configDir);
        
        final InputStream is = new File(configDir + configFile).toURL()
            .openStream();
        final Properties props = new Properties();
        try
        {
            props.load(is);
            // init Log4J
            PropertyConfigurator.configure(props);
        }
        catch (Exception e)
        {
            System.err.println("Can't read the properties file (" + 
                configDir + configFile + "). ");
        }
    }
13 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (IOException e)
                {
                    log.error("authenticateNtlm: " + e);
                }
            
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
catch (IOException e) {
	    	e.printStackTrace();
	    }
            
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
catch (IOException e) {
	    	System.out.println("There is probably no build.properties file.");
	    }
            
// in java/org/tigris/scarab/om/IssueType.java
catch(IOException ioe)
            {
                Log.get().warn("Exception while loading the file: IssueTypeConfig.properties", ioe);
            }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (IOException e)
            {
                Log.get().debug(e.getMessage());
            }
            
// in java/org/tigris/scarab/screens/ViewAttachment.java
catch (java.io.IOException ioe)
                    {
                        Log.get().debug("File download was aborted: " + 
                                        attachment.getFullPath());
                        break;
                    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (IOException ignored)
                {
                }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (IOException ignored)
            {
            }
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (IOException e) {
			throw new LoginException(e.toString());
		}
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException ex) {
                        LOG.error(ex);
                    }
3 
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (IOException e) {
			throw new LoginException(e.toString());
		}
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
0
unknown (Lib) IllegalAccessException 0 0 0 1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
0
runtime (Lib) IllegalArgumentException 21 
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getIssues(List issueIds)
        throws Exception
    {
        List issues = null;
        StringBuffer invalidIds = null;
        if (issueIds == null || issueIds.isEmpty())
        {
            issues = Collections.EMPTY_LIST;
        }
        else
        {
            if (issueIds.get(0) instanceof String)
            {
                issues = new ArrayList(issueIds.size());
                Iterator i = issueIds.iterator();
                while (i.hasNext())
                {
                    String id = (String)i.next();
                    Issue issue = getIssue(id);
                    if (issue == null)
                    {
                        if (invalidIds == null)
                        {
                            invalidIds = new StringBuffer(id);
                        }
                        else
                        {
                            invalidIds.append(' ').append(id);
                        }
                    }
                    else
                    {
                        issues.add(issue);
                    }
                }
                if (invalidIds != null)
                {
                    setAlertMessage(getLocalizationTool()
                        .format("SomeIssueIdsNotValid", invalidIds.toString()));
                }
            }
            else if (issueIds.get(0) instanceof Long)
            {
                issues = new ArrayList(issueIds.size());
                Iterator i = issueIds.iterator();
                while (i.hasNext())
                {
                    Issue issue = IssueManager.getInstance((Long)i.next());
                    if (issue == null)
                    {
                        setAlertMessage(L10NKeySet.SomeIssuePKsNotValid);
                    }
                    else
                    {
                        issues.add(issue);
                    }
                }
            }
            else
            {
                throw new IllegalArgumentException(
                    "issue ids must be Strings or Longs, not " +
                    issueIds.get(0).getClass().getName()); //EXCEPTION
            }
        }
        return issues;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private ReportBridge getNewReport(MITList mitList)
        throws Exception
    {
        if (mitList == null)
        {
            throw new IllegalArgumentException(
                "Cannot create a new report without any issue types."); //EXCEPTION
        }

        ScarabUser user = (ScarabUser)data.getUser();
        org.tigris.scarab.om.Report om  = new org.tigris.scarab.om.Report();
        ReportBridge report = new ReportBridge(om);
        report.setGeneratedBy(user);
        report.setMITList(mitList);

        String key = ((ScarabUser)data.getUser()).setCurrentReport(report);
        data.getParameters().add(ScarabConstants.CURRENT_REPORT, key);

        return report;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public void setScarabUser(ScarabUser v) throws TorqueException
    {
        if (v == null)
        {
            throw new IllegalArgumentException("cannot set user to null."); //EXCEPTION
        }

        super.setScarabUser(v);
        aScarabUser = v;
        expandedList = null;
    }
            
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getInstanceFromIssueList(List issues, 
                                                   ScarabUser user)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        
        if (user == null) 
        {
            throw new IllegalArgumentException("Null user is not allowed."); //EXCEPTION
        }
        
        MITList list = getInstance();
        list.setScarabUser(user);
        List dupeCheck = list.getMITListItems();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            MITListItem item = MITListItemManager.getInstance();
            item.setModule(issue.getModule());
            item.setIssueType(issue.getIssueType());
            if (!dupeCheck.contains(item)) 
            {
                list.addMITListItem(item);
            }
        }
        
        return list;
    }
            
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
public static RModuleIssueType getInstance(String key)
        throws TorqueException
    {
        if (key == null) 
        {
            throw new NullPointerException(
                "Cannot request a RModuleIssueType using a null key."); //EXCEPTION
        }
        int colonPos = key.indexOf(':');
        if (colonPos == -1) 
        {
            throw new IllegalArgumentException(
                "RModuleIssueType keys must be of the form N1:N2, not " + key); //EXCEPTION
        }
        // { module_id, issue_type_id } 
        SimpleKey[] keyArray = { new NumberKey(key.substring(1, colonPos)), 
            new NumberKey(key.substring(colonPos+2, key.length()-1)) 
            };
        return getInstance(new ComboKey(keyArray));
    }
            
// in java/org/tigris/scarab/om/ModuleManager.java
public static List getInstancesFromIssueList(List issues)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        

        List modules = new ArrayList();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            if (issue != null)
            {
                Module module = issue.getModule();
                if (module != null && !modules.contains(module)) 
                {
                    modules.add(module);
                }
            }
            else
            {
                throw new TorqueException("Null issue in list is not allowed."); //EXCEPTION
            }
        }
        return modules;
    }
            
// in java/org/tigris/scarab/om/UserPreferenceManager.java
public static UserPreference getInstance(Integer userid)
        throws TorqueException
    {
        if (userid == null)
        {
            throw new IllegalArgumentException("User ID cannot be null"); //EXCEPTION
        }

        UserPreference up = null;
        try
        {
            up = BaseUserPreferenceManager.getInstance(userid);
        }
        catch (TorqueException te)
        {
            // Empty result...Failed to select one and only one row.
        }
        if (up == null)
        {
            up = UserPreferenceManager.getInstance();
            up.setUserId(userid);
        }
        return up;
    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private LocalizationKey getStatusKey(NotificationStatus notification, Issue issue) 
    {
        LocalizationKey result = null;
        try
        {
            Attribute attribute = notification.getActivity().getAttribute();
            if (attribute == null || !getIsStatusAttribute(attribute, issue))
            {
                throw new IllegalArgumentException("Expected a notification containing a status attribute.");
            }

            String name = attribute.getName();
            AttributeValue av = issue.getAttributeValue(name);
            if(av != null)
            {
                result = new L10NKey(av.getValue()); // interpret the value as a L10NKey (for future use!)
            }
            else
            {
                throw new IllegalArgumentException("Received a notification containing a status attribute without a given value.");
            }
        }
        catch (TorqueException e)
        {
            Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
            Log.get().warn("db layer reported: ["+e.getMessage()+"]");
        }
        
        return result;
    }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
public Vector changeIssueAttributeOption(final String issue,
            final String user, final String attribute, final String option,
            final String description)
    {

        log("changeIssueAttributeOption:  issue=" + issue + ", user=" + user
                + ", attribute=\"" + attribute + "\"" + ", option=\"" + option
                + "\"" + ", description=\"" + description + "\"");

        final Vector retValue = new Vector();
        try
        {
            // find issue
            final Issue i = IssueManager.getIssueById(issue);
            // find user
            final ScarabUser u = ScarabUserManager.getInstance(user);
            // find attribute
            final Attribute a = Attribute.getInstance(attribute);
            // find attributeOption
            final AttributeOption o = AttributeOptionManager.getInstance(a, option);
            // proper method call
            if( i == null || u == null || a == null || o == null )
            {
                throw new IllegalArgumentException("Encountered an invalid parameter: "+i+" , "+u+" , "+a+" , "+o);
            }
            retValue.add(new Boolean(changeIssueAttributeOption(i, u, a, o,
                    description)));
        }
        catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
        catch (Exception e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
        }
        return retValue;
    }
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
public void doBuildTemplate(RunData data, TemplateContext context)
			throws Exception {
		super.doBuildTemplate(data, context);

		data.getResponse().setContentType(MIME_TYPE);

		// we will send the response, so no target to render
		data.setTarget(null);
		
		Writer writer = data.getResponse().getWriter();
		
		try {
            ParameterParser parser = data.getParameters();



            String feedType = parser.getString(FEED_TYPE_KEY);
            if(feedType == null)
            {
                String msg = COULD_NOT_FIND_FEED_TYPE;
                Log.get().error(msg);
                data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);            
                return;
            }

            String feedFormat = parser.getString(FEED_FORMAT_KEY);

            ScarabLink scarabLink= getScarabLinkTool(context);
            
            Feed feedSource = null;
            if (feedType.equals("IssueFeed")){
                String issueId = parser.getString(ISSUE_ID_KEY);                
                if(issueId.equals("")){
                    throw new IllegalArgumentException("Issue ID is missing.  Should be appended like: /issueId/xxx");
                }            	
            	Issue issue = IssueManager.getIssueById(issueId);
            	feedSource = new IssueFeed(issue,scarabLink, getLocalizationTool(context));
            }
            else {
            	throw new Exception("Couldn't find feed for type:" + feedType);
            }
            SyndFeed feed = feedSource.getFeed();

            feedFormat = (feedFormat!=null) ? feedFormat : DEFAULT_FEED_FORMAT;
            feed.setFeedType(feedFormat);

            
            SyndFeedOutput output = new SyndFeedOutput();
            output.output(feed,writer);
        }
        catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }        
        catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (FeedException ex) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,ex);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
        catch (Exception e) {
            String msg = COULD_NOT_GENERATE_FEED_ERROR;
            Log.get().error(msg,e);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }      		
	}
            
// in java/org/tigris/scarab/reports/ReportAxis.java
public ReportHeading getHeading(int headingIndex)
    {
        ReportHeading heading;
        List headings = getReportHeadings();
        if (headingIndex >= 0)
        {
            if (headings == null || headings.size() <= headingIndex) 
            {
                throw new IllegalArgumentException(headingIndex + 
                    " is larger than the number of headings"); //EXCEPTION
            }
            else 
            {
                heading = (ReportHeading)headings.get(headingIndex);
            }
        }
        else 
        {
            heading = new ReportHeading();
            addReportHeading(heading);
        }
        return heading;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
void doHandleDependencies()
        throws ScarabException, TorqueException
    {
        LOG.debug("Number of dependencies found: " + allDependencies.size());
        for (Iterator itr = allDependencies.iterator(); itr.hasNext();)
        {
            final Object[] data = (Object[])itr.next();
            final ActivitySet activitySetOM = (ActivitySet) data[0];
            final XmlActivity activity = (XmlActivity) data[1];
            

            final Dependency dependency = activity.getDependency();
            final String child = (String)issueXMLMap.get(dependency.getChild());
            final String parent = (String)issueXMLMap.get(dependency.getParent());
            if (parent == null || child == null)
            {
                if(null != parent || null != child)
                {
                    // add a comment into the issue that informs of the dependency
                    final Issue issueOM = IssueManager.getIssueById(null == parent ? child : parent);
                    final Attachment attachmentOM = new Attachment();
                    attachmentOM.setName("comment");
                    attachmentOM.setTypeId(Attachment.COMMENT__PK);
                    attachmentOM.setMimeType("text/plain");
                    // TODO i18n this
                    final String text = "Dependency \"" 
                            + parent + " (originally " + dependency.getParent() + ") " + dependency.getType() + ' ' 
                            + child + " (originally " + dependency.getParent()
                        + ") \" was not imported due to " 
                        + (null == parent ? dependency.getParent() : dependency.getChild()) + " not being resolved";
                    attachmentOM.setData(text);                    
                    issueOM.addComment(attachmentOM, ScarabUserManager.getInstance("Administrator"));
                }
                
                LOG.debug("Could not find issues: parent: " + parent + " child: " + child);
                LOG.debug("----------------------------------------------------");
                continue;
            }
            LOG.debug("doHandleDependencies: " + dependency);
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                LOG.error("[TODO] update-same-db import type not yet implemented");
                // trick here is that dependencies don't have ids or unique keys to find the 
                //  correct existing instance against.
            }
            else
            {
                try
                {
                    final String type = dependency.getType();
                    final Depend newDependOM = DependManager.getInstance();
                    final Issue parentIssueOM = IssueManager.getIssueById(parent);
                    final Issue childIssueOM = IssueManager.getIssueById(child);
                    newDependOM.setDefaultModule(parentIssueOM.getModule());
                    newDependOM.setObservedId(parentIssueOM.getIssueId());
                    newDependOM.setObserverId(childIssueOM.getIssueId());
                    newDependOM.setDependType(type);
                    LOG.debug("Dep: " + type + " Parent: " + parent + " Child: " + child);
                    LOG.debug("XML Activity id: " + activity.getId());
                    if (activity.isAddDependency())
                    {
                        parentIssueOM
                          .doAddDependency(activitySetOM, newDependOM, childIssueOM, null);
                        LOG.debug("Added Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isDeleteDependency())
                    {
                        parentIssueOM
                          .doDeleteDependency(activitySetOM, newDependOM, null);
                        LOG.debug("Deleted Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isUpdateDependency())
                    {
                        final Depend oldDependOM = parentIssueOM.getDependency(childIssueOM);
                        if (oldDependOM == null)
                        {
                            throw new IllegalArgumentException ("Whoops! Could not find the original dependency!"); //EXCEPTION
                        }
                        // we definitely know we are doing an update here.
                        newDependOM.setDeleted(false);
                        parentIssueOM
                          .doChangeDependencyType(activitySetOM, oldDependOM, newDependOM, null);
                        LOG.debug("Updated Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("Old Type: " + oldDependOM.getDependType().getName() + " New type: " + newDependOM.getDependType().getName());
                        LOG.debug("----------------------------------------------------");
                    }
                }
                catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }                
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueValidateEvent(final XmlModule module, 
            final XmlIssue issue)
        throws TorqueException
    {
        // Check for the existance of the module.
        Module moduleOM = null;
        try
        {
            moduleOM = getModuleForIssue(module,issue);
            if (moduleOM == null)
            {
                throw new IllegalArgumentException(); //EXCEPTION
            }

            // TODO: Handle user import.  Until then, ignore the
            // module's owner.
            //importUsers.add(module.getOwner());
        }
        catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }

        // Check for the existance of the issue type.
        IssueType issueTypeOM = null;
        try
        {
            issueTypeOM = IssueType.getInstance(issue.getArtifactType());
            if (issueTypeOM == null)
            {
                throw new IllegalArgumentException(); //EXCEPTION
            }
            if (!moduleOM.getRModuleIssueType(issueTypeOM).getActive())
            {
                final String error = Localization.format(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueTypeInactive", issue.getArtifactType());
                importErrors.add(error);
            }
            List moduleAttributeList = null;
            if (moduleOM != null)
            {
                moduleAttributeList = moduleOM.getAttributes(issueTypeOM);
            }

            final List activitySets = issue.getActivitySets();
            for (Iterator itr = activitySets.iterator(); itr.hasNext();)
            {
                final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
                if (activitySet.getCreatedBy() != null)
                {
                    importUsers.add(activitySet.getCreatedBy());
                }
                if (activitySet.getAttachment() != null)
                {
                    final String attachCreatedBy = activitySet.getAttachment().getCreatedBy();
                    if (attachCreatedBy != null)
                    {
                        importUsers.add(attachCreatedBy);
                    }
                }

                // Validate the activity set's type.
                try
                {
                    final ActivitySetType ttOM =
                        ActivitySetTypeManager.getInstance(activitySet.getType());
                    if (ttOM == null)
                    {
                        throw new IllegalArgumentException(); //EXCEPTION
                    }
                }
                catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }

                // Validate the activity set's date.
                validateDate(activitySet.getCreatedDate(), true);

                final List activities = activitySet.getActivities();
                for (Iterator itrb = activities.iterator(); itrb.hasNext();)
                {
                    validateActivity(moduleOM, issueTypeOM, moduleAttributeList,
                                     activitySet, (XmlActivity) itrb.next());
                }
            }
        }
        catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader readerFor(Object input)
        throws IOException
    {
        if (input instanceof FileItem)
        {
            return new InputStreamReader(((FileItem) input).getInputStream());
        }
        else if (input instanceof File)
        {
            return new BufferedReader(new FileReader((File) input));
        }
        else
        {
            throw new IllegalArgumentException(); //EXCEPTION
        }
    }
0 0 1 
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(IllegalArgumentException iae){
            String msg = COULD_NOT_GENERATE_FEED_ERROR + ": " + iae.getMessage();
            Log.get().error(msg,iae);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
0 0
runtime (Lib) IllegalStateException 6 
            
// in java/org/tigris/scarab/om/MITList.java
private void assertNotEmpty()
    {
        if (isEmpty())
        {
            throw new IllegalStateException("method should not be called on an empty list."); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public Module getModule() throws TorqueException
    {
        if (!isSingleModule())
        {
            throw new IllegalStateException(
                "method should not be called on"
                    + " a list including more than one module."); //EXCEPTION
        }
        return getModule(getFirstItem());
    }
            
// in java/org/tigris/scarab/om/MITList.java
public IssueType getIssueType() throws TorqueException
    {
        if (!isSingleIssueType())
        {
            throw new IllegalStateException(
                "method should not be called on"
                    + " a list including more than one issue type."); //EXCEPTION
        }
        return getFirstItem().getIssueType();
    }
            
// in java/org/tigris/scarab/om/MITListItem.java
public String getAttributeDisplayName(final Attribute attribute) throws TorqueException
    {
        if (!isSingleIssueType())
        {
            // FIXME: we should in fact use isSingleModuleIssueType() here
            //        but the reference of multiple modules 
            //        is represented by moduleId == MULTIPE_KEY,
            //        which has the value of 0
            //        which is also the id of the global module
            //        probably null is a better value for MULTIPE_KEY
            throw new IllegalStateException(
               "method should not be called on an item " +
               "including issue types");
        }
        Module module = getModule();
        IssueType issueType = getIssueType();
        RModuleAttribute rma = module.getRModuleAttribute(attribute, issueType);
        String displayValue;
        
        // FIXME: When would the rma be null ? I got this error today, while performing a cross module
        //        query. But i couldn't find the cause.
        //        It may be related to an inconsistent submodule definition ...
        //        In order to debug this behaviour, i added a generic displayValue here. Now the NPE
        //        is away, but the generic displayValues don't appear either on the GUI. So whatever happens
        //        here, the associated items seem to be irrelevant on the GUI... To be further examined!
        if(rma != null)
        {
        	displayValue = rma.getDisplayValue();
        }
        else
        {
        	displayValue = "" + attribute.getName() + ":" + issueType.getName();
        }
        return displayValue;
    }
            
// in java/org/tigris/scarab/util/IteratorWithSize.java
public void remove()
    {
        throw new IllegalStateException("next() will throw exception, so it is "
                                        + "not possible to call this method."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/util/WindowIterator.java
public void remove()
    {
        throw new IllegalStateException("next() will throw exception, it is "
                                        + "not possible to call this method."); //EXCEPTION
    }
0 0 0 0 0
unknown (Domain) IncompatibleMITListException 
public class IncompatibleMITListException
    extends ScarabException
{

    /**
     * Constructs a new <code>IncompatibleMITListException</code> with specified 
     * detail message.
     * 
     * @param l10nKey the error message.
     */
    public IncompatibleMITListException(LocalizationKey l10nKey)
        {
            super(l10nKey);
        }

        /**
         * Constructs a new <code>IncompatibleMITListException</code> with specified 
         * detail message.
         * 
         * @param l10nMessage the error message.
         */
        public IncompatibleMITListException(L10NMessage l10nMessage)
        {
            super(l10nMessage);
        }

        /**
         * Constructs a new <code>IncompatibleMITListException</code> with specified 
         * detail message.
         *
         * @param l10nMessage the error message.
         * @param nested
         */
        public IncompatibleMITListException(L10NMessage l10nMessage, Throwable nested)
        {
            super(l10nMessage, nested);
        }

        /**
         * Constructs a new <code>IncompatibleMITListException</code> with specified 
         * resource and a list of parameters.
         * @param theKey the l10n error key.
         * @param theParams
         */
        public IncompatibleMITListException(LocalizationKey theKey, Object[] theParams)
        {
            super(theKey, theParams);
        }

        /**
         * Convenience constructor: Constructs a new <code>IncompatibleMITListException</code>
         * with specified resource, nested Throwable and an aritrary set of parameters.
         * @param theKey the l10n error key.
         * @param nested
         * @param theParams
         */
        public IncompatibleMITListException(LocalizationKey theKey, Throwable nested, Object[] theParams)
        {
            super(theKey, nested, theParams);
        }
}
 		1 
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setMITList(MITList mitList)
        throws Exception
    {
        if (mitList == null) 
        {
            reportDefn.setModuleIssueTypes(null);
            setModule(null);
            setIssueType(null);
        }
        else 
        {
            boolean isOk = true;
            // need to check that the changes are compatible with the currently
            // selected criteria
            for (Iterator roai = reportDefn
                .retrieveAllReportOptionAttributes().iterator(); 
                 roai.hasNext() && isOk;) 
            {
                isOk = mitList.isCommon( AttributeOptionManager.getInstance( 
                    ((ReportOptionAttribute)roai.next())
                    .getOptionId()));
            }
            for (Iterator ruai = reportDefn
                .retrieveAllReportUserAttributes().iterator(); 
                 ruai.hasNext() && isOk;) 
            {
                isOk = mitList.isCommon( AttributeManager.getInstance( 
                    ((ReportUserAttribute)ruai.next())
                    .getAttributeId()));
            }
            
            if (!isOk) 
            {
                throw new IncompatibleMITListException(L10NKeySet.ExceptionIncompatibleMITListChanges); //EXCEPTION
            }
            
            reportDefn.setModuleIssueTypes(null);
            setModule(null);
            setIssueType(null);

            for (Iterator i = mitList.getExpandedMITListItems().iterator(); i.hasNext();) 
            {
                MITListItem item = (MITListItem)i.next();
                ModuleIssueType mit = new ModuleIssueType();
                mit.setModuleId(item.getModuleId());
                mit.setIssueTypeId(item.getIssueTypeId());
                reportDefn.addModuleIssueType(mit);
            }
            if (mitList.isSingleModule()) 
            {
                torqueReport.setModule(mitList.getModule());
            }
            if (mitList.isSingleIssueType()) 
            {
                torqueReport.setIssueType(mitList.getIssueType());
            }
        }
    }
0 0 1 
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
catch (IncompatibleMITListException e)
        {
            scarabR.setAlertMessage(L10NKeySet.IncompatibleMITListReport);
            setTarget(data, "reports,XModuleList.vm");
        }
0 0
unknown (Lib) IndexOutOfBoundsException 3 
            
// in java/org/tigris/scarab/search/CachedResultList.java
public Object get(int index)
	{
	    if(index>query.totalRowCount())
	    {
	        throw new IndexOutOfBoundsException();
	    }
	    else if(index>query.cachedRowCount())
	    {
	        query.cacheAll();
		    if(index>query.cachedRowCount())
		    	index = query.cachedRowCount();
	    }
	    return query.getCachedRows().get(index);
	}
            
// in java/org/tigris/scarab/reports/ReportTableModel.java
public Object getValueAt(int row, int column)
        throws Exception
    {
        if (row < 0 || row >= getRowCount())
        {
            throw new IndexOutOfBoundsException("Row index was " + row); //EXCEPTION
        }
        
        if (column < 0 || column >= getColumnCount()) 
        {
            throw new IndexOutOfBoundsException("Column index was " + column); //EXCEPTION
        }

        Object contents = ReportManager.getMethodResult().get(this,GET_VALUE_AT,new Integer(row),new Integer(column));

        if(contents==null){
        
            //could use a categories list to make this simpler
            if (columnHeadings != null && columnHeadings.size() == 1 && 
                    ((ReportHeading)columnHeadings.get(0)).get(0) instanceof ReportDate) 
            {
                Date date = ((ReportDate) ((ReportHeading) columnHeadings.get(0))
                             .get(column)).dateValue();
                if (date.getTime() <= System.currentTimeMillis())
                {
                    contents = new Integer(getIssueCount(getRowDataArray(row),
                                                         date));
                }
                else
                {
                    // Dates in the future are not applicable to reporting.
                    contents = "";
                }
            }
            else if (rowHeadings != null && rowHeadings.size() == 1 && 
                     ((ReportHeading)rowHeadings.get(0)).get(0) instanceof ReportDate)
            {
                Date date = ((ReportDate)((ReportHeading)rowHeadings.get(0))
                             .get(row)).dateValue();
                if (date.getTime() <= System.currentTimeMillis())
                {
                   contents = new Integer(getIssueCount(
                        getColumnDataArray(column), date));
                }
                else
                {
                   // Dates in the future are not applicable to reporting.
                   contents = "";
                }
            }
            else if (columnHeadings != null && columnHeadings.size() == 1 && 
                    ((ReportHeading)columnHeadings.get(0)).get(0) instanceof ReportDateRange) 
            {
            	Date minDate =((ReportDateRange)((ReportHeading)columnHeadings.get(0))
                        .get(column)).getMinDate(searcher.getLocale());
            	
            	Date maxDate = ((ReportDateRange)((ReportHeading)columnHeadings.get(0))
                        .get(column)).getMaxDate(searcher.getLocale());
            	
            	contents = new Integer(getIssueCountRange(
                        getRowDataArray(row), minDate, maxDate));
            	
            }
            else if (rowHeadings != null && rowHeadings.size() == 1 && 
                     ((ReportHeading)rowHeadings.get(0)).get(0) instanceof ReportDateRange)
            {
            	Date minDate = ((ReportDateRange)((ReportHeading)rowHeadings.get(0))
                        .get(row)).getMinDate(searcher.getLocale());
            	
            	Date maxDate = ((ReportDateRange)((ReportHeading)rowHeadings.get(0))
                        .get(row)).getMaxDate(searcher.getLocale());
            	
            	contents = new Integer(getIssueCountRange(
                        getColumnDataArray(column), minDate, maxDate));
            }
            else
            {
                contents = new Integer(getIssueCount(
                    getRowDataArray(row), getColumnDataArray(column), date)); 
            }

            ReportManager.getMethodResult().put(contents,this,GET_VALUE_AT,new Integer(row),new Integer(column));
        }

        return contents;
    }
0 0 0 0 0
unknown (Lib) InitializationException 6 
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void init()
        throws InitializationException
    {
        try
        {
            initVelocity();
            // Register with the template service.
            registerConfiguration("ve");
            setInit(true);
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private void initVelocity()
        throws InitializationException
    {
        // Now we have to perform a couple of path translations
        // for our log file and template paths.
        String path = getRealPath(
            getConfiguration().getString(VelocityEngine.RUNTIME_LOG, null));

        if (path != null && path.length() > 0)
        {
            getConfiguration().setProperty(VelocityEngine.RUNTIME_LOG, path);
        }
        else
        {
            String msg = EmailService.SERVICE_NAME + " runtime log file " +
                "is misconfigured: '" + path + "' is not a valid log file";

            throw new Error(msg); //EXCEPTION
        }

        // Get all the template paths where the velocity
        // runtime should search for templates and
        // collect them into a separate vector
        // to avoid concurrent modification exceptions.
        String key;
        List keys = new ArrayList();
        for (Iterator i = getConfiguration().getKeys(); i.hasNext();)
        {
            key = (String) i.next();
            if (key.endsWith(RESOURCE_LOADER_PATH))
            {
                keys.add(key);
            }
        }

        // Loop through all template paths, clear the corresponding
        // velocity properties and translate them all to the webapp space.
        int ind;
        List paths;
        String entry;
        for (Iterator i = keys.iterator(); i.hasNext();)
        {
            key = (String) i.next();
            paths = getConfiguration().getList(key,null);
            if (paths != null)
            {
                velocityEngine.clearProperty(key);
                getConfiguration().clearProperty(key);

                for (Iterator j = paths.iterator(); j.hasNext();)
                {
                    path = (String) j.next();
                    if (path.startsWith(JAR_PREFIX + "file"))
                    {
                        // A local jar resource URL path is a bit more
                        // complicated, but we can translate it as well.
                        ind = path.indexOf("!/");
                        if (ind >= 0)
                        {
                            entry = path.substring(ind);
                            path = path.substring(9,ind);
                        }
                        else
                        {
                            entry = "!/";
                            path = path.substring(9);
                        }
                        path = JAR_PREFIX + "file:" + getRealPath(path) +
                            entry;
                    }
                    else if (path.startsWith(ABSOLUTE_PREFIX))
                    {
                        path = path.substring (ABSOLUTE_PREFIX.length(),
                                               path.length());
                    }
                    else if (!path.startsWith(JAR_PREFIX))
                    {
                        // But we don't translate remote jar URLs.
                        path = getRealPath(path);
                    }
                    // Put the translated paths back to the configuration.
                    getConfiguration().addProperty(key,path);
                }
            }
        }

        try
        {
            velocityEngine.setExtendedProperties(ConfigurationConverter
                    .getExtendedProperties(getConfiguration()));

            velocityEngine.init();
        }
        catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
public void init()
        throws InitializationException
    {
        try
        {
            String dbState =
                GlobalParameterManager.getString(DB_L10N_STATE);
            if (PRE_L10N.equals(dbState) || STARTED_L10N.equals(dbState))
            {
                long start = System.currentTimeMillis();
                Log.get().info("New scarab database; localizing strings for '" +
                               ScarabConstants.DEFAULT_LOCALE.getDisplayName() + "'...");
                GlobalParameterManager.setString(DB_L10N_STATE, STARTED_L10N);
                initdb(ScarabConstants.DEFAULT_LOCALE);     
                GlobalParameterManager.setString(DB_L10N_STATE, POST_L10N);
                Log.get().info("Done localizing.  Time elapsed = " + 
                    (System.currentTimeMillis()-start)/1000.0 + " s");
            }

            checkNewHttpParameters();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }

        // indicate that the service initialized correctly
        setInit(true);
    }
            
// in java/org/tigris/scarab/services/TorqueService.java
public void init()
        throws InitializationException
    {
        try
        {
            Torque.init(Turbine.getConfiguration());
            Log.get("org.apache.fulcrum").info("  Loading om instances via managers...");
            loadOM();
            Log.get("org.apache.fulcrum").info("  Done loading om instances.");
        }
        catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }

        // indicate that the service initialized correctly
        setInit(true);
    }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }

        JCSCache = JCS.getInstance(SCARAB_CACHE_REGION);

        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }

    }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
        maps = new WeakHashMap();
        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
        
    }
6 
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/TorqueService.java
catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
5 
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void init()
        throws InitializationException
    {
        try
        {
            initVelocity();
            // Register with the template service.
            registerConfiguration("ve");
            setInit(true);
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to initialize VelocityEmailService", e); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private void initVelocity()
        throws InitializationException
    {
        // Now we have to perform a couple of path translations
        // for our log file and template paths.
        String path = getRealPath(
            getConfiguration().getString(VelocityEngine.RUNTIME_LOG, null));

        if (path != null && path.length() > 0)
        {
            getConfiguration().setProperty(VelocityEngine.RUNTIME_LOG, path);
        }
        else
        {
            String msg = EmailService.SERVICE_NAME + " runtime log file " +
                "is misconfigured: '" + path + "' is not a valid log file";

            throw new Error(msg); //EXCEPTION
        }

        // Get all the template paths where the velocity
        // runtime should search for templates and
        // collect them into a separate vector
        // to avoid concurrent modification exceptions.
        String key;
        List keys = new ArrayList();
        for (Iterator i = getConfiguration().getKeys(); i.hasNext();)
        {
            key = (String) i.next();
            if (key.endsWith(RESOURCE_LOADER_PATH))
            {
                keys.add(key);
            }
        }

        // Loop through all template paths, clear the corresponding
        // velocity properties and translate them all to the webapp space.
        int ind;
        List paths;
        String entry;
        for (Iterator i = keys.iterator(); i.hasNext();)
        {
            key = (String) i.next();
            paths = getConfiguration().getList(key,null);
            if (paths != null)
            {
                velocityEngine.clearProperty(key);
                getConfiguration().clearProperty(key);

                for (Iterator j = paths.iterator(); j.hasNext();)
                {
                    path = (String) j.next();
                    if (path.startsWith(JAR_PREFIX + "file"))
                    {
                        // A local jar resource URL path is a bit more
                        // complicated, but we can translate it as well.
                        ind = path.indexOf("!/");
                        if (ind >= 0)
                        {
                            entry = path.substring(ind);
                            path = path.substring(9,ind);
                        }
                        else
                        {
                            entry = "!/";
                            path = path.substring(9);
                        }
                        path = JAR_PREFIX + "file:" + getRealPath(path) +
                            entry;
                    }
                    else if (path.startsWith(ABSOLUTE_PREFIX))
                    {
                        path = path.substring (ABSOLUTE_PREFIX.length(),
                                               path.length());
                    }
                    else if (!path.startsWith(JAR_PREFIX))
                    {
                        // But we don't translate remote jar URLs.
                        path = getRealPath(path);
                    }
                    // Put the translated paths back to the configuration.
                    getConfiguration().addProperty(key,path);
                }
            }
        }

        try
        {
            velocityEngine.setExtendedProperties(ConfigurationConverter
                    .getExtendedProperties(getConfiguration()));

            velocityEngine.init();
        }
        catch(Exception e)
        {
            // This will be caught and rethrown by the init() method.
            // Oh well, that will protect us from RuntimeException folk showing
            // up somewhere above this try/catch
            throw new InitializationException(
                "Failed to set up VelocityEmailService", e); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
public void init()
        throws InitializationException
    {
        try
        {
            String dbState =
                GlobalParameterManager.getString(DB_L10N_STATE);
            if (PRE_L10N.equals(dbState) || STARTED_L10N.equals(dbState))
            {
                long start = System.currentTimeMillis();
                Log.get().info("New scarab database; localizing strings for '" +
                               ScarabConstants.DEFAULT_LOCALE.getDisplayName() + "'...");
                GlobalParameterManager.setString(DB_L10N_STATE, STARTED_L10N);
                initdb(ScarabConstants.DEFAULT_LOCALE);     
                GlobalParameterManager.setString(DB_L10N_STATE, POST_L10N);
                Log.get().info("Done localizing.  Time elapsed = " + 
                    (System.currentTimeMillis()-start)/1000.0 + " s");
            }

            checkNewHttpParameters();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new InitializationException(
                "Failed to localize default data!", e); //EXCEPTION
        }

        // indicate that the service initialized correctly
        setInit(true);
    }
            
// in java/org/tigris/scarab/services/TorqueService.java
public void init()
        throws InitializationException
    {
        try
        {
            Torque.init(Turbine.getConfiguration());
            Log.get("org.apache.fulcrum").info("  Loading om instances via managers...");
            loadOM();
            Log.get("org.apache.fulcrum").info("  Done loading om instances.");
        }
        catch (Exception e)
        {
            throw new InitializationException("Can't initialize Torque!", e); //EXCEPTION
        }

        // indicate that the service initialized correctly
        setInit(true);
    }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
public void init() throws InitializationException {
		super.init();
        Configuration cfg = Turbine.getConfiguration().subset("scarab.login.ldap");
        if ((cfg != null) && 
        	(getConfiguration().getBoolean("synchronizeOnStartUp",false))) {
			try {
				LDAPSynchronizer syncher = new LDAPSynchronizer(cfg);
				syncher.synchronize(); 
			} catch (NamingException e) {
				log.error("NamingException caught synchronizing accounts: ",e);
			}
        }
	}
0 0 0
unknown (Lib) InstantiationException 0 0 0 1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
1 
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
0
unknown (Lib) IntrospectionException 0 0 2 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected BeanReader createScarabIssuesBeanReader()
        throws ParserConfigurationException,IntrospectionException,SAXNotRecognizedException,
            SAXNotSupportedException
    {
        BeanReader reader = new BeanReader()
            {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }
            };

        // Connecting Digster's logger to ours logs too verbosely.
        //reader.setLogger(LOG);
        reader.register(SYSTEM_DTD_URI, INTERNAL_DTD_URI);
        // Be forgiving about the encodings we accept.
        reader.setFeature("http://apache.org/xml/features/allow-java-encodings",
                          true);
        reader.setXMLIntrospector(createXMLIntrospector());
        reader.registerBeanClass(ScarabIssues.class);
        NameMapper nm = reader.getXMLIntrospector().getNameMapper();
        reader.addRule(nm.mapTypeToElementName
                       (new BeanDescriptor(ScarabIssues.class).getName()),
                       new ScarabIssuesSetupRule());
        reader.setErrorHandler(this);
        return reader;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected void write(final Object bean, final Writer out)
        throws IOException,SAXException,IntrospectionException
    {
        final BeanWriter writer = new BeanWriter(out);
        writer.setXMLIntrospector(createXMLIntrospector());
        writer.enablePrettyPrint();
        writer.setWriteIDs(false);
        writer.write(bean);
    }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
0
unknown (Lib) JDOMException 0 0 2 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader getScarabFormattedReader(
            final Object input,
            final ImportType type,
            final Module currModule) throws IOException, TransformerException, TorqueException, JDOMException 
    {
        Reader returnValue = null;
        
        if( SCARAB == type )
        {
            // is in correct format already, just return the input stream
            returnValue = readerFor(input);
        }
        else if( BUGZILLA == type )
        {
            // Location of the extensions directory for Bugzilla
            // Transform configuration, mappings and attachments are here
            // TODO move onto resourceDirectory derivative
            final String extensions = System.getProperty("catalina.home") + "/../extensions/bugzilla";
            
            // Locate the Bugzilla to Scarab XSL transform
            final InputStream xsl = getClass().getResourceAsStream(BUGZILLA_XSL);
            
            // Transform Bugzilla xml to scarab format
            // (Trailing '/' to resources is deliberate)
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, extensions);
            
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        else if( JIRA == type )
        {
                    
            // transform xml to scarab format
            final InputStream xsl = getClass().getResourceAsStream(JIRA_XSL);
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, resourceDirectory);
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        return returnValue;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader insertModuleNode(final Reader result, 
            final Module currModule) 
        throws TorqueException, JDOMException, IOException, TransformerException 
    {
        
        final ScarabUser user = ScarabUserManager.getInstance(currModule.getOwnerId());        
        
        // Core Java: org.w3c.dom version (jdk1.4+ compatible)
//        final DocumentBuilder docBuilder = documentBuilderFactory.newDocumentBuilder();
//        final Document doc = docBuilder.parse( new InputSource(result) );
//        // insert module
//        final Element root = doc.getDocumentElement();
//        final Element moduleNode = doc.createElement("module");
//        final Element idNode = doc.createElement("id");
//        final Element parentIdNode = doc.createElement("parent-id");
//        final Element nameNode = doc.createElement("name");
//        final Element ownerNode = doc.createElement("owner");
//        final Element descriptionNode = doc.createElement("description");
//        final Element urlNode = doc.createElement("url");
//        final Element domainNode = doc.createElement("domain");
//        final Element codeNode = doc.createElement("code");
//        
//        idNode.appendChild(doc.createTextNode(String.valueOf(currModule.getModuleId())));
//        parentIdNode.appendChild(doc.createTextNode(String.valueOf(currModule.getParentId())));
//        nameNode.appendChild(doc.createTextNode(currModule.getName()));
//        ownerNode.appendChild(doc.createTextNode(user.getUserName()));
//        descriptionNode.appendChild(doc.createTextNode(currModule.getDescription()));
//        urlNode.appendChild(doc.createTextNode(currModule.getUrl()));
//        domainNode.appendChild(doc.createTextNode(currModule.getHttpDomain()));
//        codeNode.appendChild(doc.createTextNode(currModule.getCode()));
//        
//        moduleNode.appendChild(idNode);
//        moduleNode.appendChild(parentIdNode);
//        moduleNode.appendChild(nameNode);
//        moduleNode.appendChild(ownerNode);
//        moduleNode.appendChild(descriptionNode);
//        moduleNode.appendChild(urlNode);
//        moduleNode.appendChild(domainNode);
//        moduleNode.appendChild(codeNode);
//        
//        root.appendChild(moduleNode);
        
        // JDom version (jdk1.3 compatible)
        
        final SAXBuilder builder = new SAXBuilder();
        builder.setEntityResolver(new EntityResolver()
        {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }   
        });
        final Document doc = builder.build(result);        
        final Element root = doc.getRootElement();

        final Element moduleNode = new Element("module");
        final Element idNode = new Element("id");
        final Element parentIdNode = new Element("parent-id");
        final Element nameNode = new Element("name");
        final Element ownerNode = new Element("owner");
        final Element descriptionNode = new Element("description");
        final Element urlNode = new Element("url");
        final Element domainNode = new Element("domain");
        final Element codeNode = new Element("code");    
        
        idNode.setText(String.valueOf(currModule.getModuleId()));
        parentIdNode.setText(String.valueOf(currModule.getParentId()));
        nameNode.setText(currModule.getRealName());
        ownerNode.setText(user.getUserName());
        descriptionNode.setText(currModule.getDescription());
        urlNode.setText(currModule.getUrl());
        domainNode.setText(currModule.getHttpDomain());
        codeNode.setText(currModule.getCode());
        
        moduleNode.addContent(idNode)
                .addContent(parentIdNode)
                .addContent(nameNode)
                .addContent(ownerNode)
                .addContent(descriptionNode)
                /*
                 * These are excluded for now, since your database domain may 
                 * not correspond to currModule.getHttpDomain().
                .addContent(urlNode)
                .addContent(domainNode)
                 */
                .addContent(codeNode);
        root.addContent(2,moduleNode);
        
        return transformXML(new JDOMSource(doc), null, currModule, null);
    }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
0
unknown (Lib) LoginException 7 
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean login() throws LoginException {
		Callback[] calls = new Callback[3];
        LDAPUserInfoCallback ldapUserInfo =  new LDAPUserInfoCallback();
		calls[0] = new NameCallback("name");
		calls[1] = new PasswordCallback("Password", false);
        calls[2] =  ldapUserInfo;
		
		if (callbackHandler == null)
			throw new LoginException("callback is null");

		try {
			callbackHandler.handle(calls);
		} catch (IOException e) {
			throw new LoginException(e.toString());
		} catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}

		cbName = ((NameCallback) calls[0]).getName();
		if (cbName.equals(null))
			throw new LoginException("name must not be null");
		
		cbPassword = String.valueOf(((PasswordCallback) (calls[1])).getPassword());
		if (cbPassword.equals(null))
			throw new LoginException("password must not be null");
		
		try {
			props = new Hashtable();
			props.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
			props.put(Context.PROVIDER_URL, options.get(HOST_KEY));
            ctx = new InitialDirContext(props);
            SearchControls cons = new SearchControls();
            cons.setSearchScope(SearchControls.SUBTREE_SCOPE);
            NamingEnumeration results = ctx.search((String)options.get(BASEDN_KEY),"uid={0}",new Object[] { cbName },cons);
            Attributes attributes = null;
            String principal = null;
            while (results.hasMore()){
                SearchResult sr = (SearchResult)results.next();
                attributes = sr.getAttributes();
                principal = sr.getName() + "," + options.get(BASEDN_KEY);
            }
            if ( attributes == null || principal == null){
                throw new LoginException("No User Found");
            }
            ctx.close();
			props.put(Context.SECURITY_PRINCIPAL, principal);
			props.put(Context.SECURITY_CREDENTIALS, cbPassword);
			props.put(Context.SECURITY_AUTHENTICATION, "simple");
			ctx = new InitialDirContext(props);
			verification = true;
            ldapUserInfo.setEmail(attributes.get("mail").get().toString());
            ldapUserInfo.setGivenname(attributes.get("givenname").get().toString());
            ldapUserInfo.setSn(attributes.get("sn").get().toString());
			ctx.close();
		} catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
		
		return verification;
	}
3 
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (IOException e) {
			throw new LoginException(e.toString());
		}
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
4 
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean abort() throws LoginException {
		return true;
	}
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean commit() throws LoginException {
		return true;
	}
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean login() throws LoginException {
		Callback[] calls = new Callback[3];
        LDAPUserInfoCallback ldapUserInfo =  new LDAPUserInfoCallback();
		calls[0] = new NameCallback("name");
		calls[1] = new PasswordCallback("Password", false);
        calls[2] =  ldapUserInfo;
		
		if (callbackHandler == null)
			throw new LoginException("callback is null");

		try {
			callbackHandler.handle(calls);
		} catch (IOException e) {
			throw new LoginException(e.toString());
		} catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}

		cbName = ((NameCallback) calls[0]).getName();
		if (cbName.equals(null))
			throw new LoginException("name must not be null");
		
		cbPassword = String.valueOf(((PasswordCallback) (calls[1])).getPassword());
		if (cbPassword.equals(null))
			throw new LoginException("password must not be null");
		
		try {
			props = new Hashtable();
			props.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
			props.put(Context.PROVIDER_URL, options.get(HOST_KEY));
            ctx = new InitialDirContext(props);
            SearchControls cons = new SearchControls();
            cons.setSearchScope(SearchControls.SUBTREE_SCOPE);
            NamingEnumeration results = ctx.search((String)options.get(BASEDN_KEY),"uid={0}",new Object[] { cbName },cons);
            Attributes attributes = null;
            String principal = null;
            while (results.hasMore()){
                SearchResult sr = (SearchResult)results.next();
                attributes = sr.getAttributes();
                principal = sr.getName() + "," + options.get(BASEDN_KEY);
            }
            if ( attributes == null || principal == null){
                throw new LoginException("No User Found");
            }
            ctx.close();
			props.put(Context.SECURITY_PRINCIPAL, principal);
			props.put(Context.SECURITY_CREDENTIALS, cbPassword);
			props.put(Context.SECURITY_AUTHENTICATION, "simple");
			ctx = new InitialDirContext(props);
			verification = true;
            ldapUserInfo.setEmail(attributes.get("mail").get().toString());
            ldapUserInfo.setGivenname(attributes.get("givenname").get().toString());
            ldapUserInfo.setSn(attributes.get("sn").get().toString());
			ctx.close();
		} catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
		
		return verification;
	}
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
public boolean logout() throws LoginException {
		return true;
	}
2 
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (LoginException e) {
            log.error(
                "Unable to create LDAP jaas login context. Forget to add jaas config to JVM? Try adding -Djava.security.auth.login.config=jaas.conf to servlet container.");
            log.error(e);
        }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (LoginException e) {
            cbh.clearPassword();
            log.info(e);

            return null;
        }
0 0
unknown (Lib) MissingResourceException 0 0 0 5 
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (MissingResourceException noKey)
        {
            // No need for logging (already done in base class).
            value = null;
        }
            
// in java/org/tigris/scarab/tools/ScarabLocalizationTool.java
catch (MissingResourceException noKey)
        {
            value = null;
        }
            
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		}
            
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		}
            
// in java/org/tigris/scarab/services/DatabaseInitializer.java
catch (MissingResourceException e)
                            {
                                Log.get().debug("Missing database initialization "
                                                + "resource: " + e.getMessage());
                            }
0 0
unknown (Lib) NamingException 0 0 2 
            
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
private String getAttributeValue(Attribute attrib, String deflt)
			throws NamingException {
		String result = deflt;
		if (attrib != null) {
			result = (String) attrib.get(0);
		}
		return result;
	}
            
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
public void synchronize() throws NamingException {
		InitialDirContext ctx;
		NamingEnumeration results;

		Hashtable props = new Hashtable();
		props.put(Context.INITIAL_CONTEXT_FACTORY, providerFactory);
		props.put(Context.PROVIDER_URL, providerUrl);
		ctx = new InitialDirContext(props);

		SearchControls cons = new SearchControls();
		cons.setSearchScope(SearchControls.SUBTREE_SCOPE);
		results = ctx.search(baseDn, query, null, cons);

		while (results.hasMore()) {
			try {
				synchUser((SearchResult) results.next());
			} catch (NamingException e) {
				logger.error("NamingException caught: ", e);
			} catch (Exception e) {
				logger.error("Exception caught: ", e);
			}
		}

	}
3 
            
// in java/org/tigris/scarab/services/security/ldap/LDAPSynchronizer.java
catch (NamingException e) {
				logger.error("NamingException caught: ", e);
			}
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (NamingException e) {
				log.error("NamingException caught synchronizing accounts: ",e);
			}
1 
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (NamingException e) {
			throw new LoginException(e.toString() + "  " + e.getRootCause());
		}
0
unknown (Lib) NoRowsException 0 0 0 7 
            
// in java/org/tigris/scarab/om/Transition.java
catch (NoRowsException e)
        {
            //Nothing to do, just ignore it
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (NoRowsException e)
            {
                //Nothing to do, just ignore it
            }
            
// in java/org/tigris/scarab/om/Transition.java
catch (NoRowsException e)
        {
            //Nothing to do, just ignore it
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (NoRowsException e)
        {
            // ignore and return null, if the rmit does not exist
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (NoRowsException e)
        {
            // Nothing to do. Ignore.
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (NoRowsException e)
            {
                // No error.
            }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (NoRowsException e) {
                    log.error("No Rows exception when sorting IssueTypeOptions.",e);
                }
0 0
unknown (Lib) NoSuchElementException 4 
            
// in java/org/tigris/scarab/util/IteratorWithSize.java
public Object next()
    {
        throw new NoSuchElementException("This is an empty list."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/util/WindowIterator.java
public Object next()
    {
        if (hasNext()) 
        {
            hasNext = null;
            return window[bsize];
        }
        else 
        {
            throw new NoSuchElementException("Iterator is exhausted"); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/util/WindowIterator.java
public Object next()
    {
        throw new NoSuchElementException("This is an empty list."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/util/WindowIterator.java
public Object get(int i)
    {
        throw new NoSuchElementException("This is an empty list."); //EXCEPTION
    }
0 0 1 
            
// in java/org/tigris/scarab/om/ActivitySet.java
catch (NoSuchElementException nsee)
                        {
                            Throwable th = new Throwable("No such element exception occured.(ignore and assume transitionToSealed=false)");
                            th.printStackTrace();
                            result = false;
                        }
0 0
unknown (Lib) NotActiveException 0 0 0 1 
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (java.io.NotActiveException e)
        {
        }
0 0
runtime (Lib) NullPointerException 2 
            
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
public static RModuleIssueType getInstance(String key)
        throws TorqueException
    {
        if (key == null) 
        {
            throw new NullPointerException(
                "Cannot request a RModuleIssueType using a null key."); //EXCEPTION
        }
        int colonPos = key.indexOf(':');
        if (colonPos == -1) 
        {
            throw new IllegalArgumentException(
                "RModuleIssueType keys must be of the form N1:N2, not " + key); //EXCEPTION
        }
        // { module_id, issue_type_id } 
        SimpleKey[] keyArray = { new NumberKey(key.substring(1, colonPos)), 
            new NumberKey(key.substring(colonPos+2, key.length()-1)) 
            };
        return getInstance(new ComboKey(keyArray));
    }
            
// in java/org/tigris/scarab/reports/ReportTableModel.java
private void addOptionOrGroup(int alias, Object optionOrGroup, 
                                  Date minDate, Date maxDate, Criteria crit)
    {
        if (optionOrGroup == null) 
        {
            throw new NullPointerException("cell definition cannot contain nulls"); //EXCEPTION
        }

        String a = "a"+alias;
        String t = "t"+alias;
        // there is some redundancy here, but over specifying the joins usually
        // allows the query optimizer to obtain a better optimization
        crit.addJoin(a + '.' + ACT_ISSUE_ID, IssuePeer.ISSUE_ID);
        for (int i=alias-1; i>=0; i--) 
        {
            crit.addJoin("a"+i+'.'+ACT_ISSUE_ID, a+'.'+ACT_ISSUE_ID);
        }
        crit.addAlias("a"+alias, ActivityPeer.TABLE_NAME);
        crit.addAlias("t"+alias, ActivitySetPeer.TABLE_NAME);
        
        crit.addJoin(a+"."+ACT_TRANSACTION_ID, t+'.'+TRAN_TRANSACTION_ID);
        
        if(maxDate != null){
        	crit.add(t, TRAN_CREATED_DATE, maxDate, Criteria.LESS_THAN); 
        }

        if(minDate != null){
        	crit.add(t, TRAN_CREATED_DATE, minDate, Criteria.GREATER_THAN); 
        }
        
        // end date criteria
        Criteria.Criterion c1 = crit
            .getNewCriterion(a, ACT_END_DATE, date, Criteria.GREATER_THAN);
        c1.or(crit.getNewCriterion(a, ACT_END_DATE, null, Criteria.EQUAL));
        crit.add(c1);

        if (optionOrGroup instanceof ReportGroup) 
        {
            List options = ((ReportGroup)optionOrGroup)
                .getReportOptionAttributes();
            if (options != null && options.size() > 0) 
            {            
                Integer[] nks = new Integer[options.size()];
                for (int i=0; i<nks.length; i++) 
                {
                    nks[i] = ((ReportOptionAttribute)options.get(i))
                        .getOptionId();
                }
                
                crit.addIn(a+'.'+ACT_NEW_OPTION_ID, nks);
            }
            else 
            {
                List users = ((ReportGroup)optionOrGroup)
                    .getReportUserAttributes();
                if (users != null && users.size() > 0) 
                {            
                    Integer[] nks = new Integer[users.size()];
                    for (int i=0; i<nks.length; i++) 
                    {
                        nks[i] = ((ReportUserAttribute)users.get(i))
                            .getUserId();
                    }
                    
                    crit.addIn(a+'.'+ACT_NEW_USER_ID, nks);
                }
                else 
                {
                    // group is empty make sure there are no results
                    crit.add(a+'.'+ACT_NEW_OPTION_ID, -1);
                }
            }
        }
        else if (optionOrGroup instanceof ReportOptionAttribute)
        {
            crit.add(a, ACT_NEW_OPTION_ID, 
                     ((ReportOptionAttribute)optionOrGroup).getOptionId());
        }
        else if (optionOrGroup instanceof ReportUserAttribute)
        {
            ReportUserAttribute rua = (ReportUserAttribute)optionOrGroup;
            Integer attributeId = rua.getAttributeId();
            if (attributeId.intValue() == 0)
            {
                // committed by
                crit.add(t, TRAN_TYPE_ID, 
                         ActivitySetTypePeer.CREATE_ISSUE__PK);
                crit.add(t, TRAN_CREATED_BY, rua.getUserId());
            }
            else 
            {
                crit.add(a, ACT_ATTRIBUTE_ID, rua.getAttributeId());
                crit.add(a, ACT_NEW_USER_ID, rua.getUserId());
            }
        }
    }
0 0 1 
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (NullPointerException npe)
            {
                // Something wrong in the database ?
                displayValue="";
            }
0 0
unknown (Lib) NumberFormatException 0 0 0 5 
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (NumberFormatException noIssueType)
            {
            }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
catch( NumberFormatException e)
        {
            return null;
        }
            
// in java/org/tigris/scarab/attribute/IntegerAttribute.java
catch(NumberFormatException nfe)
            {
                Log.get().warn("non integer string in VALUE field for IntegerAttribute");
            }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
catch (NumberFormatException nfe) // new Integer(issueId) above could fail
        {
            getScarabRequestTool(context).setAlertMessage(L10NKeySet.BadIntegerConversion);
        }
            
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
catch (NumberFormatException nfe)
                    {
                        pref.setInternalAttribute(ids[i]);
                        orderMap.put(pref.getInternalAttribute(), order);
                    }
0 0
unknown (Lib) ParseException 6 
            
// in java/org/tigris/scarab/screens/admin/ActivityList.java
private Date parseDate(String s)
        throws ParseException
    {
        SimpleDateFormat[] sdf = {
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"),
            new SimpleDateFormat("yyyy-MM-dd HH:mm"),
            new SimpleDateFormat("yyyy-MM-dd"),
            new SimpleDateFormat("HH:mm:ss"),
            new SimpleDateFormat("HH:mm")
                };

        Date date = null;
        for (int i=0; i<sdf.length-1; i++) 
        {
            try 
            {
                date = sdf[i].parse(s);
            }
            catch (ParseException e)
            {
                // try the next one
            }
        }

        if (date == null) 
        {
            //TODO [HD] Shouldn't this be better a NPE ?
            //          That better hits the truth...
            throw new ParseException(s + " could not be parsed as a date", 0); //EXCEPTION
        }
        return date;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void validateDate(final BaseDate xmlDate, final boolean required)
    {
        try
        {
            // Report parse error failures even for optional dates.
            if ((xmlDate != null && xmlDate.getDate() == null) && required)
            {
                // Trigger error handling.
                throw new ParseException(null, -1); //EXCEPTION
            }
        }
        catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
    }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
private static Date parseDate(String s, String[] patterns)
        throws ParseException
    {
        if (s == null) 
        {
            throw new ParseException("Input string was null", -1);
        }

        SimpleDateFormat formatter = new SimpleDateFormat();

        for (int i = 0; i < patterns.length; i++) 
        {
        	Date date = null;
        	formatter.applyPattern(patterns[i]);
            try
            {
            	date = formatter.parse(s);
            }
            catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }            
            if (date != null) 
            {
                return date;
            }
        }
        
        throw new ParseException("Date could not be parsed with any"
                                 + " of the provided date patterns.", -1);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Date parseDate(String s, String[] patterns)
        throws ParseException
    {
        if (s == null) 
        {
            throw new ParseException("Input string was null", -1);
        }

        if (formatter == null) 
        {
            formatter = new SimpleDateFormat();
        }
        
        for (int i = 0; i < patterns.length; i++) 
        {
        	Date date = null;
        	formatter.applyPattern(patterns[i]);
            try
            {
            	date = formatter.parse(s);
            }
            catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }            
            if (date != null) 
            {
                return date;
            }
        }
        
        throw new ParseException("Date could not be parsed with any"
                                 + " of the provided date patterns.", -1);
    }
0 19 
            
// in java/org/tigris/scarab/attribute/DateAttribute.java
public static Date toDate(String value) throws ParseException
    {
        Date result = internalFormat.parse(value);
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public long getHoursIdle() throws TorqueException, ParseException
    {
        Date now = new Date();
        Date date = null;
        Date onHoldUntil = null;
        long diffHours = 0;

        if (!isNew()) 
        {
            boolean onHold = isOnHold();
            if(onHold)
            {
                onHoldUntil = getOnHoldUntil(); // on Hold until this date
                if(onHoldUntil == null)
                {
                    return 0; // we are on hold but there is no end date, so we wait forever.
                }
                diffHours = (now.getTime() - onHoldUntil.getTime()) / (1000*60*60);
                if(diffHours < 0)
                {
                    return 0; // onHoldDate not yet reached, so we are not idle by definition
                }
            }
            ActivitySet t = getLastActivitySet();
            if (t == null)
            {
                date = getCreatedDate();
            }
            else 
            {
                date = t.getCreatedDate();
            }
            
            if(onHold)
            {
                if (date.before(onHoldUntil))
                {
                    // The date of last activity was before the onHoldUntil date
                    // In that case we count the end of the onHold period as the
                    // event.
                    date = onHoldUntil;
                }
            }
            
        }
        // Return the difference in hours between now and the last date of activities:
        diffHours = (now.getTime() - date.getTime()) / (1000*60*60);
        return diffHours;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Date getOnHoldUntil() throws TorqueException, ParseException
    {
        return mystate.getOnHoldUntil();
    }
            
// in java/org/tigris/scarab/screens/admin/ActivityList.java
private Date parseDate(String s)
        throws ParseException
    {
        SimpleDateFormat[] sdf = {
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"),
            new SimpleDateFormat("yyyy-MM-dd HH:mm"),
            new SimpleDateFormat("yyyy-MM-dd"),
            new SimpleDateFormat("HH:mm:ss"),
            new SimpleDateFormat("HH:mm")
                };

        Date date = null;
        for (int i=0; i<sdf.length-1; i++) 
        {
            try 
            {
                date = sdf[i].parse(s);
            }
            catch (ParseException e)
            {
                // try the next one
            }
        }

        if (date == null) 
        {
            //TODO [HD] Shouldn't this be better a NPE ?
            //          That better hits the truth...
            throw new ParseException(s + " could not be parsed as a date", 0); //EXCEPTION
        }
        return date;
    }
            
// in java/org/tigris/scarab/reports/ReportDateRange.java
public Date getMinDate(Locale locale)
    throws ParseException
    {
    	
    	if(minDateString == null || minDateString.trim().equals(""))
        {
    		
    		return null;
    		
    	}
    	
    	return ScarabUtil.parseDate(minDateString, false, locale);
    	
    }
            
// in java/org/tigris/scarab/reports/ReportDateRange.java
public Date getMaxDate(Locale locale)
    throws ParseException
    {
    	
    	if(maxDateString == null || maxDateString.trim().equals(""))
        {
    		
    		return null;
    		
    	}
    	
    	return ScarabUtil.parseDate(maxDateString, false, locale);
    	
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public Date getOnHoldUntil() throws TorqueException, ParseException
    {
        Date date = null;
        String attributeName = Environment.getConfigurationProperty("scarab.common.status.onhold.dateProperty", null);
        
        if (attributeName != null)
        {
            AttributeValue dateValue = issue.getAttributeValue(attributeName);
            if(dateValue!=null) 
            {
                String value = dateValue.getValue();
                if (value != null && value.length() > 0)
                {
                    date = DateAttribute.toDate(value);
                }
            }
        }
        return date;
    }
            
// in java/org/tigris/scarab/util/xmlissues/BaseDate.java
public Date getDate()
        throws ParseException
    {
        Date date = null;
        String ts = getTimestamp();
        if (StringUtils.isNotEmpty(ts))
        {
            String format = getFormat();
            boolean haveFormat = StringUtils.isNotEmpty(format);
            try
            {
                SimpleDateFormat sdf =
                    new SimpleDateFormat(haveFormat ? format : DEFAULT_FORMAT);
                sdf.setLenient(false);
                date = sdf.parse(getTimestamp());
            }
            catch (ParseException e)
            {
                if (haveFormat)
                {
                    // When a format was explicitly specified,
                    // propogate any parsing problems.
                    throw e;
                }
            }
        }
        return date;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueEvent(final XmlModule module, final XmlIssue issue)
        throws TorqueException,ScarabException,ParseException
    {
/////////////////////////////////////////////////////////////////////////////////  
        // Get me an issue
        Issue issueOM = null;
        final String issueID = (issue.hasModuleCode() ? "" : module.getCode()) + issue.getId();
        if (getImportTypeCode() == CREATE_SAME_DB || getImportTypeCode() == CREATE_DIFFERENT_DB)
        {
            // Check if the new issue nominates an ID and if the database does
            // not already contain an issue with that ID
            if (issue.getId() != null && IssueManager.getIssueById(issueID) == null)
            {
                // Create the new issue with the nominated ID
                issueOM = createNewIssue(module, issue, issue.getId());
            }
            else
            {
                // Crate the new issue with an automatically allocated ID
                issueOM = createNewIssue(module, issue, null);
            }
        }
        else if (getImportTypeCode() == UPDATE_SAME_DB) // nice to specify just for searching/refactoring
        {
            issueOM = IssueManager.getIssueById(issueID);
            
            if (issueOM == null)
            {
                issueOM = createNewIssue(module, issue, null);
            }
            else
            {
                LOG.debug("Found Issue in db: " + issueOM.getUniqueId());
            }
        }

/////////////////////////////////////////////////////////////////////////////////  

        // Loop over the XML activitySets
        final List activitySets = issue.getActivitySets();
        LOG.debug("-----------------------------------");
        LOG.debug("Number of ActivitySets in Issue: " + activitySets.size());
        for (Iterator itr = activitySets.iterator(); itr.hasNext();)
        {
            final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
            LOG.debug("Processing ActivitySet: " + activitySet.getId());

/////////////////////////////////////////////////////////////////////////////////  
            // Deal with the attachment for the activitySet
            final XmlAttachment activitySetAttachment = activitySet.getAttachment();
            Attachment activitySetAttachmentOM = null;
            if (activitySetAttachment != null)
            {
                if (getImportTypeCode() == UPDATE_SAME_DB)
                {
                    try
                    {
                        activitySetAttachmentOM = AttachmentManager
                            .getInstance(activitySetAttachment.getId());
                        LOG.debug("Found existing ActivitySet Attachment");
                    }
                    catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
                }
                else
                {
                    activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    LOG.debug("Created ActivitySet Attachment object");
                }
            }
            else
            {
                LOG.debug("OK- No Attachment in this ActivitySet");
            }

/////////////////////////////////////////////////////////////////////////////////  
            // Attempt to get the activitySet OM
            boolean alreadyCreated = false;
            ActivitySet activitySetOM = null;
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                try
                {
                    activitySetOM = ActivitySetManager.getInstance(activitySet.getId());
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in db: " + activitySetOM.getActivitySetId());
                }
                catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            }
            else
            {
                // first try to get the ActivitySet from the internal map
                if (activitySetIdMap.containsKey(activitySet.getId()))
                {
                    activitySetOM = ActivitySetManager.getInstance(
                        (String)activitySetIdMap.get(activitySet.getId()));
                    alreadyCreated = true;
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in map: " + activitySetOM.getActivitySetId());
                }
                else // it hasn't been encountered previously
                {
                    activitySetOM = ActivitySetManager.getInstance();
                    LOG.debug("Created new ActivitySet");
                }
            }

            final ScarabUser activitySetCreatedByOM = findUser(activitySet.getCreatedBy());
            
            if (LOG.isDebugEnabled())
            {
                LOG.debug("ActivitySet: " + activitySet.getId() + "; of type: " + activitySet.getType() + "; by: " + activitySet.getCreatedBy());
                LOG.debug("   alreadyCreated: " + alreadyCreated);
            }
            
            if (!alreadyCreated)
            {
                // Populate the ActivitySet
                // Get the ActivitySet type/createdby values (we know these are valid)
                final ActivitySetType ttOM = ActivitySetTypeManager.getInstance(activitySet.getType());
                activitySetOM.setActivitySetType(ttOM);
                if( activitySetCreatedByOM != null ){
                    activitySetOM.setCreatedBy(activitySetCreatedByOM.getUserId());
                }
                else
                {
                	// Anonymous user. better than nothing.
                	try {
						activitySetOM.setCreatedBy(ScarabUserManager.getAnonymousUser().getUserId());
					} catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                }
                activitySetOM.setCreatedDate(activitySet.getCreatedDate().getDate());
                if (activitySetAttachmentOM != null)
                {
                    activitySetAttachmentOM.save();
                    activitySetOM.setAttachment(activitySetAttachmentOM);
                }
                activitySetOM.save();
                if( activitySet.getId() != null){
                    // if id is valid, save for later re-use.
                    activitySetIdMap.put(activitySet.getId(), 
                                         activitySetOM.getPrimaryKey().toString());
                }
            }

            // Determine if this ActivitySet should be marked as the 
            // creation event
            final ActivitySet creationSet = issueOM.getActivitySetRelatedByCreatedTransId();
            if (ActivitySetTypePeer.CREATE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) 
               ||
               (ActivitySetTypePeer.MOVE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) && 
                        (creationSet == null || activitySetOM.getCreatedDate()
                         .before(creationSet.getCreatedDate()))) ) 
            {
                issueOM.setActivitySetRelatedByCreatedTransId(activitySetOM);
                issueOM.save();
            }

/////////////////////////////////////////////////////////////////////////////////  
// Deal with changing user attributes. this code needs to be in this *strange*
// location because we look at the entire activityset in order to determine
// that this is a change user activity set. of course in the future, it would
// be really nice to create an activityset/activiy type that more accurately 
// reflects what type of change this is. so that it is easier to case for. for
// now, we just look at some fingerprints to determine this information. -JSS

            if (activitySet.isChangeUserAttribute())
            {
                final List activities = activitySet.getActivities();
                final XmlActivity activityA = (XmlActivity)activities.get(0);
                final XmlActivity activityB = (XmlActivity)activities.get(1);
                
                final ScarabUser assigneeOM = findUser(activityA.getOldUser());
                final ScarabUser assignerOM = findUser(activityB.getNewUser());

                final Attribute oldAttributeOM = Attribute.getInstance(activityA.getAttribute());

                final AttributeValue oldAttValOM = issueOM.getUserAttributeValue(assigneeOM, oldAttributeOM);
                if (oldAttValOM == null)
                {
                    LOG.error("User '" + assigneeOM.getName() + "' was not previously '" + oldAttributeOM.getName() + "' to the issue!");
                }

                // Get the Attribute associated with the new Activity
                final Attribute newAttributeOM = Attribute.getInstance(activityB.getAttribute());

                issueOM.changeUserAttributeValue(activitySetOM,
                            assigneeOM, 
                            assignerOM, 
                            oldAttValOM,
                            newAttributeOM, null);
                LOG.debug("-------------Updated User AttributeValue------------");
                continue;
            }

/////////////////////////////////////////////////////////////////////////////////  

            // Deal with the activities in the activitySet
            final List activities = activitySet.getActivities();
            LOG.debug("Number of Activities in ActivitySet: " + activities.size());

            final LinkedMap avMap = issueOM.getModuleAttributeValuesMap();
            LOG.debug("Total Module Attribute Values: " + avMap.size());
            for (Iterator itrb = activities.iterator(); itrb.hasNext();)
            {
                final XmlActivity activity = (XmlActivity) itrb.next();
                LOG.debug("Looking at activity id: " + activity.getId());

                // Get the Attribute associated with the Activity
                final Attribute attributeOM = Attribute.getInstance(activity.getAttribute());

                // deal with the activity attachment (if there is one)
                final XmlAttachment activityAttachment = activity.getAttachment();
                Attachment activityAttachmentOM = null;
                if (activityAttachment != null)
                {
                    // look for an existing attachment in the activity
                    // the case is when we have a URL and we create it
                    // and then delete it, the attachment id is still the
                    // same so there is no reason to re-create the attachment
                    // again.
                    final String previousXmlId = activityAttachment.getId();
                    final String previousId = (String)attachmentIdMap.get(previousXmlId);
                    if (previousId == null) 
                    {
                        activityAttachmentOM = createAttachment(issueOM, activityAttachment);
                        activityAttachmentOM.save();
                        attachmentIdMap.put(previousXmlId, activityAttachmentOM.getPrimaryKey().toString());
                        
                        // Special case. After the Attachment object has been 
                        // saved, if the ReconcilePath == true, then assume 
                        // that the fileName is an absolute path to a file and
                        // copy it to the right directory
                        // structure under Scarab's path.
                        if (allowFileAttachments && activityAttachment.getReconcilePath())
                        {
                            try
                            {
                                activityAttachmentOM
                                    .copyFileFromTo(activityAttachment.getFilename(), 
                                                    activityAttachmentOM.getFullPath());
                            } 
                            catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            } 
                            catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                        }
                        LOG.debug("Created Activity Attachment object");
                    }
                    else 
                    {
                        activityAttachmentOM = AttachmentManager
                            .getInstance(previousId);
                        LOG.debug("Found existing Activity Attachment");
                    }
                }
                else
                {
                    LOG.debug("OK- No Attachment in this Activity");
                }

                // deal with null attributes (need to do this before we create the 
                // activity right below because this will create its own activity).
                if (attributeOM.equals(nullAttribute))
                {
                    // add any dependency activities to a list for later processing
                    if (isDependencyActivity(activity))
                    {
                        if (!isDuplicateDependency(activity))
                        {
                            final Object[] obj = {activitySetOM, activity, activityAttachmentOM};
                            allDependencies.add(obj);
                            dependActivitySetId.add(activity.getDependency());
                            LOG.debug("-------------Stored Dependency # " 
                                    + allDependencies.size() + '[' + activity.getDependency() + ']');
                            continue;
                        }
                    }
                    else
                    {
                        // create the activity record.
                        ActivityManager.createTextActivity(issueOM, nullAttribute, activitySetOM, 
                                    ActivityType.getActivityType(activity.getActivityType()), activity.getDescription(), activityAttachmentOM, 
                                    activity.getOldValue(), activity.getNewValue());
        
                        LOG.debug("-------------Saved Null Attribute-------------");
                        continue;
                    }
                }

                // create the activityOM
                createActivity(activity, module, 
                                            issueOM, attributeOM, activitySetOM);

                // check to see if this is a new activity or an update activity
                AttributeValue avalOM = null;
                for (Iterator moduleAttributeValueItr = avMap.mapIterator(); 
                     moduleAttributeValueItr.hasNext() && avalOM == null;)
                {
                    final AttributeValue testAvalOM = (AttributeValue)
                        avMap.get(moduleAttributeValueItr.next());
                    final Attribute avalAttributeOM = testAvalOM.getAttribute();

                    LOG.debug("Checking Attribute match: " + avalAttributeOM.getName() + 
                              " against: " + attributeOM.getName());
                    if (avalAttributeOM.equals(attributeOM))
                    {
                        avalOM = testAvalOM;
                    }
                }

                if (avalOM != null) 
                {
                    final Attribute avalAttributeOM = avalOM.getAttribute();
                    LOG.debug("Attributes match!");
                    AttributeValue avalOM2 = null;
                    if (!activity.isNewActivity())
                    {
                        LOG.debug("Activity is not new.");
                        avalOM2 = AttributeValue.getNewInstance(
                            avalAttributeOM.getAttributeId(), 
                            avalOM.getIssue());
                        avalOM2.setProperties(avalOM);
                    }

                    if (avalAttributeOM.isOptionAttribute())
                    {
                        LOG.debug("We have an Option Attribute: " + 
                                  avalAttributeOM.getName());
                        final AttributeOption newAttributeOptionOM = 
                                AttributeOptionManager.getInstance(
                                         attributeOM, activity.getNewOption(),
                                         issueOM.getModule(),
                                         issueOM.getIssueType());
                        if (activity.isNewActivity())
                        {
                            if (newAttributeOptionOM != null)
                            {
                                avalOM.setOptionId(newAttributeOptionOM.getOptionId());
                                avalOM.startActivitySet(activitySetOM);
                                avalOM.setAttribute(attributeOM);
                                avalOM.save();
                                LOG.debug("-------------Saved Attribute Value-------------");
                            }
                            else
                            {
                                LOG.warn("NewAttributeOptionOM is null for " +
                                         activity.getNewOption());
                            }
                        }
                        else if(newAttributeOptionOM != null)
                        {
                            avalOM2.setOptionId(newAttributeOptionOM.getOptionId());
                            final HashMap map = new HashMap();
                            map.put(avalOM.getAttributeId(), avalOM2);
                            issueOM.setAttributeValues(activitySetOM, map, null, activitySetCreatedByOM);
                            LOG.debug("-------------Saved Option Attribute Change-------------");
                        }
                    }
                    else if (avalAttributeOM.isUserAttribute())
                    {
                        LOG.debug("We have a User Attribute: " 
                                  + avalAttributeOM.getName());
                        if (activity.isNewActivity())
                        {
                            // Don't need to pass in the attachment because
                            // it is already in the activitySetOM.
                            // If we can't get an assignee new-user, then 
                            // use the activity set creator as assignee.
                            ScarabUser assigneeOM = findUser(activity.getNewUser());
                            assigneeOM = (assigneeOM != null)
                                ? assigneeOM: activitySetCreatedByOM;
                            if( assigneeOM != null ){
                                issueOM.assignUser(activitySetOM, 
                                    assigneeOM, null, avalAttributeOM, null);
                            }
                            LOG.debug("-------------Saved User Assign-------------");
                        }
                        else if (activity.isRemoveUserActivity())
                        {
                            // remove a user activity
                            final ScarabUser oldUserOM = findUser(activity.getOldUser());
                            // need to reset the aval because the current one
                            // is marked as new for some reason which causes an
                            // insert and that isn't the right behavior here 
                            // (we want an update)
                            avalOM = null;
                            for (Iterator i = issueOM.getAttributeValues(
                                 avalAttributeOM).iterator(); 
                                 i.hasNext() && avalOM == null;) 
                            {
                                final AttributeValue av = (AttributeValue)i.next();
                                if (oldUserOM.getUserId().equals(av.getUserId())) 
                                {
                                    avalOM = av;
                                }
                            }

                            if (avalOM == null) 
                            {
                                if (LOG.isDebugEnabled()) 
                                {
                                    LOG.debug("Could not find previous AttributeValue assigning " +
                                        (oldUserOM == null ? "NULL" : 
                                        oldUserOM.getUserName()) + 
                                        " to attribute " + 
                                              avalAttributeOM.getName());
                                }                                
                            }
                            else 
                            {
                                // don't need to pass in the attachment because
                                // it is already in the activitySetOM
                                issueOM.deleteUser(activitySetOM, oldUserOM, 
                                    activitySetCreatedByOM, avalOM, null);
                                LOG.debug("-------------Saved User Remove-------------");
                            }
                        }
                    }
                    else if (avalAttributeOM.isTextAttribute() || avalAttributeOM.isIntegerAttribute())
                    {
                        LOG.debug("We have a Text Attribute: " + avalAttributeOM.getName());

                        avalOM.startActivitySet(activitySetOM);
                        avalOM.setAttribute(attributeOM);

                        if (activity.isNewActivity())
                        {
                            avalOM.setValue(activity.getNewValue());
                        }
                        else if (!activity.getNewValue()
                                .equals(avalOM.getValue()))
                        {
                            avalOM2.setValue(activity.getNewValue());
                            avalOM.setProperties(avalOM2);
                        }
                        
                        avalOM.save();
                        LOG.debug("-------------Saved Attribute Value-------------");
                    }
                }
                issueOM.save();
                LOG.debug("-------------Saved Issue-------------");
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Activity createActivity(final XmlActivity activity,  
                                         final XmlModule module,
                                         final Issue issueOM, 
                                         final Attribute attributeOM,
                                         final ActivitySet activitySetOM)
        throws TorqueException, ParseException, ScarabException
    {
        Activity activityOM = null;
        if (getImportTypeCode() == UPDATE_SAME_DB)
        {
            try
            {
                activityOM = ActivityManager.getInstance(activity.getId());
            }
            catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
        }
        else
        {
            activityOM = ActivityManager.getInstance();
        }

        activityOM.setIssue(issueOM);
        activityOM.setAttribute(attributeOM);
        activityOM.setActivityType(ActivityType.OTHER.getCode());
        activityOM.setActivitySet(activitySetOM);
        if (activity.getEndDate() != null)
        {
            activityOM.setEndDate(activity.getEndDate().getDate());
        }

        // Set the attachment for the activity
        Attachment newAttachmentOM = null;
        if (activity.getAttachment() != null)
        {
            newAttachmentOM = createAttachment(issueOM, activity.getAttachment());
            newAttachmentOM.save();
            activityOM.setAttachment(newAttachmentOM);
        }

        LOG.debug("Created New Activity");
        return activityOM;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Attachment createAttachment(final Issue issueOM, 
            final XmlAttachment attachment)
        throws TorqueException, ScarabException, ParseException
    {
        final Attachment attachmentOM = AttachmentManager.getInstance();
        attachmentOM.setIssue(issueOM);
        final AttachmentType type = AttachmentType.getInstance(attachment.getType());
        if (allowFileAttachments || !Attachment.FILE__PK.equals(type.getAttachmentTypeId())) 
        {
            attachmentOM.setName(attachment.getName());
            attachmentOM.setAttachmentType(type);
            attachmentOM.setMimeType(null != attachment.getMimetype()
                    ? attachment.getMimetype()
                    : ComponentLocator.getMimeTypeService().getContentType(attachment.getFilename(), null));
            attachmentOM.setFileName(attachment.getFilename());        
            attachmentOM.setData(attachment.getData());
        }
        else 
        {
            // add a comment that the file will not be imported.  An alternative would be
            // to skip the activity altogether, but we will then need to check that there 
            // are other activities or we need to completely ignore the ActivitySet
            attachmentOM.setName("comment");
            attachmentOM.setTypeId(Attachment.COMMENT__PK);
            attachmentOM.setMimeType("text/plain");
            String text = "File, " + attachment.getFilename() + 
                ", was not imported. The old description follows:\n\n" + attachment.getName();
            final String data = attachment.getData();  // this should be null, but just in case
            if (data != null) 
            {
                text += "\n\n" + data;
            }
            attachmentOM.setData(text);
        }
        
        attachmentOM.setCreatedDate(attachment.getCreatedDate().getDate());
        final ModifiedDate modifiedDate = attachment.getModifiedDate();
        if (modifiedDate != null)
        {
            attachmentOM.setModifiedDate(modifiedDate.getDate());
        }
        final ScarabUser creUser = findUser(attachment.getCreatedBy());
        if (creUser != null)
        {
            attachmentOM.setCreatedBy(creUser.getUserId());
        }

        final String modifiedBy = attachment.getModifiedBy();
        if (modifiedBy != null)
        {
            final ScarabUser modUserOM = findUser(attachment.getModifiedBy());
            if (modUserOM != null)
            {
                attachmentOM.setModifiedBy(modUserOM.getUserId());
            }
        }

        attachmentOM.setDeleted(attachment.getDeleted());
        return attachmentOM;
    }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
private static Date parseDate(String dateString, Localizable dateFormat, Locale locale) 
    throws ParseException
    {
    	Date date;
    	
    	ScarabLocalizationTool l10n = new ScarabLocalizationTool();
        l10n.init(locale);
    	
    	String[] patterns = {
                            l10n.get(dateFormat),
                            ScarabConstants.ISO_DATETIME_PATTERN };
    	date = parseDate(dateString, patterns);
    	return date;
    	
    }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
private static Date parseDate(String s, String[] patterns)
        throws ParseException
    {
        if (s == null) 
        {
            throw new ParseException("Input string was null", -1);
        }

        SimpleDateFormat formatter = new SimpleDateFormat();

        for (int i = 0; i < patterns.length; i++) 
        {
        	Date date = null;
        	formatter.applyPattern(patterns[i]);
            try
            {
            	date = formatter.parse(s);
            }
            catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }            
            if (date != null) 
            {
                return date;
            }
        }
        
        throw new ParseException("Date could not be parsed with any"
                                 + " of the provided date patterns.", -1);
    }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
public static Date parseDate(String dateString, boolean addTwentyFourHours, Locale locale)
        throws ParseException
    {
        Date date = null;
        if (dateString != null) 
        {
            Matcher m = RELATIVE_DATE_PATTERN.matcher(dateString);
        	if(m.matches())
        	{
                date = new Date();

        		    String dateDifference = m.group(3);
        		    String sign = m.group(2);
        		    if(dateDifference!=null)
        		{
                    long hours = Long.parseLong(dateDifference);  
                    if (sign.equals("-")) hours = hours * -1;
                    date.setTime(date.getTime() + hours * 3600000 );
        		}
        	}
            else if (dateString.indexOf(':') == -1)
            {
                date = parseDate(dateString, L10NKeySet.ShortDatePattern, locale);
                
                if (addTwentyFourHours) 
                {                
                    date.setTime(date.getTime() + 86399999);
                }
            }
            else
            {
                date = parseDate(dateString, L10NKeySet.ShortDateTimePattern, locale);        
            }
        }
        
        return date;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public Date parseDate(String dateString, boolean addTwentyFourHours)
        throws ParseException
    {
        Date date = null;
        if (dateString != null) 
        {
            Matcher m = RELATIVE_DATE_PATTERN.matcher(dateString);
        	if(m.matches())
        	{
                date = new Date();

        		    String dateDifference = m.group(3);
        		    String sign = m.group(2);
        		    if(dateDifference!=null)
        		{
                    long hours = Long.parseLong(dateDifference);  
                    if (sign.equals("-")) hours = hours * -1;
                    date.setTime(date.getTime() + hours * 3600000 );
        		}
        	}
            else if (dateString.indexOf(':') == -1)
            {
                date = parseDate(dateString, L10NKeySet.ShortDatePattern);
                
                if (addTwentyFourHours) 
                {                
                    date.setTime(date.getTime() + 86399999);
                }
            }
            else
            {
                date = parseDate(dateString, L10NKeySet.ShortDateTimePattern);        
            }
        }
        
        return date;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Date parseDate(String dateString, Localizable dateFormat) 
        throws ParseException
    {
        Date date;
        String[] patterns = {
            L10N.get(dateFormat),
            ScarabConstants.ISO_DATETIME_PATTERN };
        date = parseDate(dateString, patterns);
        return date;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private Date parseDate(String s, String[] patterns)
        throws ParseException
    {
        if (s == null) 
        {
            throw new ParseException("Input string was null", -1);
        }

        if (formatter == null) 
        {
            formatter = new SimpleDateFormat();
        }
        
        for (int i = 0; i < patterns.length; i++) 
        {
        	Date date = null;
        	formatter.applyPattern(patterns[i]);
            try
            {
            	date = formatter.parse(s);
            }
            catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }            
            if (date != null) 
            {
                return date;
            }
        }
        
        throw new ParseException("Date could not be parsed with any"
                                 + " of the provided date patterns.", -1);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addDateRangeCriteria( Criteria crit, String column, 
                                  String minDateStr, String maxDateStr)
        throws java.text.ParseException
    {        
        Date minDate = parseDate(minDateStr, false);
        Date maxDate = parseDate(maxDateStr, true);
    
        if(minDate!=null)
        {
            crit.and(column, minDate, Criteria.GREATER_EQUAL);
        }
        if(maxDate!=null)
        {
            crit.and(column, maxDate, Criteria.LESS_EQUAL);
        }
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addTransDateRange(Criteria crit, 
                                 String alias,
                                 String baseColumn,
                                 String minDateStr, String maxDateStr)
        throws java.text.ParseException
    {
        if(minDateStr != null || maxDateStr != null)
        {
            crit.addAlias(alias, ActivitySetPeer.TABLE_NAME);
            crit.addJoin( 
                baseColumn, 
                useAlias(alias,ActivitySetPeer.TRANSACTION_ID), 
                Criteria.INNER_JOIN 
            );
            addDateRangeCriteria(crit,useAlias(alias, ActivitySetPeer.CREATED_DATE),
                                 minDateStr,maxDateStr);    
        } 
    }
9 
            
// in java/org/tigris/scarab/attribute/DateAttribute.java
catch (ParseException e)
        {
            // Will return the same value
        }
            
// in java/org/tigris/scarab/attribute/DateAttribute.java
catch (ParseException e)
        {
        	// Will return the same value
        }
            
// in java/org/tigris/scarab/screens/admin/ActivityList.java
catch (ParseException e)
            {
                // try the next one
            }
            
// in java/org/tigris/scarab/util/xmlissues/BaseDate.java
catch (ParseException e)
            {
                if (haveFormat)
                {
                    // When a format was explicitly specified,
                    // propogate any parsing problems.
                    throw e;
                }
            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            final String errorMsg =
                (e.getErrorOffset() != -1 ? ": " + e.getMessage() : "");
            final String[] args = { xmlDate.getTimestamp(), xmlDate.getFormat(),
                              errorMsg };
            final String error = Localization.format
                (ScarabConstants.DEFAULT_BUNDLE_NAME, getLocale(),
                 "InvalidDate", args);
            importErrors.add(error);
        }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (ParseException ex)
            {
                // ignore, because we have to try all patterns
            }
3 
            
// in java/org/tigris/scarab/util/xmlissues/BaseDate.java
catch (ParseException e)
            {
                if (haveFormat)
                {
                    // When a format was explicitly specified,
                    // propogate any parsing problems.
                    throw e;
                }
            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }
0
unknown (Lib) ParserConfigurationException 0 0 4 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected void validate(final String name, 
            final Reader is,
            final BeanReader reader, 
            final Module currentModule)
        throws ParserConfigurationException,SAXException,IOException
    {
        // While parsing the XML, we perform well formed-ness and DTD
        // validation (if present, see Xerces dynamic feature).
        setValidationMode(reader, true);
        ScarabIssues si = null;
        try
        {
            si = (ScarabIssues) reader.parse(is);
        }
        catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }

        // If the XML is okay, validate the actual content.
        if (si != null)
        {
            // ASSUMPTION: Parse errors prevent entry into this block.
            validateContent(si, currentModule);

            // Log any errors encountered during import.
            if (importErrors != null)
            {
                final int nbrErrors = importErrors.size();
                LOG.error("Found " + nbrErrors + " error" +
                          (nbrErrors == 1 ? "" : "s") + " importing '" +
                          name + "':");
                for (Iterator itr = importErrors.iterator(); itr.hasNext(); )
                {
                    LOG.error(itr.next());
                }
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected ScarabIssues insert(
            final String name, 
            final Reader is, 
            final BeanReader reader)
        throws ParserConfigurationException,SAXException,IOException,ScarabException, TorqueException
    {
        setValidationMode(reader, false);
        final ScarabIssues si = (ScarabIssues)reader.parse(is);
        si.doHandleDependencies();
        LOG.debug("Successfully imported " + name + '!');
        return si;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private void setValidationMode(Digester reader, boolean state)
        throws ParserConfigurationException, SAXException
    {
        this.validationMode = state;

        // Setup the XML parser SAX2 features.

        // Turn on DTD validation (these are functionally equivalent
        // with Xerces 1.4.4 and likely most other SAX2 impls).
        reader.setValidating(state);
        reader.setFeature("http://xml.org/sax/features/validation", state);

        // Validate the document only if a grammar is specified
        // (http://xml.org/sax/features/validation must be state).
        reader.setFeature("http://apache.org/xml/features/validation/dynamic",
                          state);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected BeanReader createScarabIssuesBeanReader()
        throws ParserConfigurationException,IntrospectionException,SAXNotRecognizedException,
            SAXNotSupportedException
    {
        BeanReader reader = new BeanReader()
            {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }
            };

        // Connecting Digster's logger to ours logs too verbosely.
        //reader.setLogger(LOG);
        reader.register(SYSTEM_DTD_URI, INTERNAL_DTD_URI);
        // Be forgiving about the encodings we accept.
        reader.setFeature("http://apache.org/xml/features/allow-java-encodings",
                          true);
        reader.setXMLIntrospector(createXMLIntrospector());
        reader.registerBeanClass(ScarabIssues.class);
        NameMapper nm = reader.getXMLIntrospector().getNameMapper();
        reader.addRule(nm.mapTypeToElementName
                       (new BeanDescriptor(ScarabIssues.class).getName()),
                       new ScarabIssuesSetupRule());
        reader.setErrorHandler(this);
        return reader;
    }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
0
unknown (Lib) PasswordMismatchException 0 0 1 
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
public User getAuthenticatedUser(String username, String password)
        throws DataBackendException, UnknownEntityException, 
            PasswordMismatchException {
        LDAPUserInfoCallback info = authenticate(username, password);

        /* First try to auth from ldap */
        if (info != null) {
            /* Check if user exists */
            if (!super.userManager.accountExists(username)) {
                try {
                    super.userManager.createAccount(createUser(username,
                            password, info), password);
                } catch (EntityExistsException e) {
                }

                
            } else {
                User curruser = userManager.retrieve(username);
                copyProps(curruser, info);

                String encrypted = TurbineSecurity.encryptPassword(password);

                if (!encrypted.equals(curruser.getPassword())) {
                    curruser.setPassword(encrypted);
                }

                userManager.store(curruser);
            }

            return userManager.retrieve(username);
        }

        return userManager.retrieve(username, password);
    }
2 
            
// in java/org/tigris/scarab/actions/ChangePassword.java
catch (PasswordMismatchException pme)
                {
                    scarabR.setAlertMessage(l10n.getMessage(pme));
                    setTarget(data, template);
                }
            
// in java/org/tigris/scarab/actions/Login.java
catch (PasswordMismatchException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().debug("Password mis-match during login attempt: "
                           + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
0 0
unknown (Lib) RESyntaxException 0 0 0 3 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException e)
        {
            getLog().error("Could not compile regex: " + regex, e);
            try
            {
                rep = rec.compile(REGEX_PREFIX + REGEX_SUFFIX);
            }
            catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
0 0
runtime (Lib) RuntimeException 38 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
public void invoke(RunData data, ValveContext context) throws IOException, TurbineException
    {
        try
        {
    	   if (bNTLMActive &&
                   (
                   ((null == data.getUserFromSession() || data.getUserFromSession().getUserName().trim().length()==0) && null == data.getUser())
                   || ((ScarabUser)data.getUserFromSession()).isUserAnonymous()
                   )
                   && ( !data.getAction().equals("Logout")
                           && !data.getAction().equals("Login")
                           && !data.getTarget().equals("Register.vm")
                           && !data.getTarget().equals("ForgotPassword.vm")
                    ))
            {
                authenticateNtlm(data);
            }
        }
        catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
    	   context.invokeNext(data);       
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private List<RModuleAttribute> getRModuleUserAttributes(ScarabUser user, Module module, IssueType issueType, MITList currentList) 
    {
        List<RModuleAttribute> issueListColumns = null;
        try {
            //
            // First check whether an MIT list is currently
            // active and if so, whether it has attributes
            // associated with it.
            //
            if (currentList != null) {
                //
                // Here we fetch the collection of attributes
                // associated with the current MIT list.
                //

                //issueListColumns = currentList.getCommonRModuleUserAttributes();
                ensure_List_has_MIT_data(currentList, module, issueType);
                issueListColumns = currentList.getAllRModuleUserAttributes();

                //
                // If there are no attributes associated with
                // the list, and the list only contains a single
                // module and a single issue type, get the default
                // attributes for that combination of module and
                // issue type.
                //
                if (issueListColumns.isEmpty()
                        && currentList.isSingleModuleIssueType()) {
                    issueListColumns = currentList.getModule()
                            .getDefaultRModuleUserAttributes(
                                    currentList.getIssueType());
                }

                // TODO repeat the above when single module but two or more issuetypes
                // TODO looking for common default attributes.
            }

            if (issueListColumns == null || issueListColumns.size() == 0)
            {
                issueListColumns = user.getRModuleUserAttributes(module, issueType);
                if (issueListColumns.isEmpty()) 
                {
                    issueListColumns = module.getDefaultRModuleUserAttributes(issueType);
                }
            }
            
            if (issueListColumns == null)
            {
                issueListColumns = Collections.EMPTY_LIST;
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        return issueListColumns;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getCurrentSearchResults()
    {
        List queryResults = Collections.EMPTY_LIST;
        try
        {
            queryResults = getUnprotectedCurrentSearchResults();
            if (queryResults.size() == 0)
            {
                setInfoMessage(L10NKeySet.NoMatchingIssues);
            }
        }
        catch (ScarabException e)
        {
            setAlertMessage(e.getL10nMessage());
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }

        return queryResults;
    }
            
// in java/org/tigris/scarab/search/CachedQuery.java
public List getResults()
    {
        if(countOnly)
        	throw new RuntimeException("is countOnly!");

        if(results==null)
    		results = new CachedResultList(this);
    	
    	return results;
    }
            
// in java/org/tigris/scarab/search/CachedQuery.java
public void cacheInitial()
    {
    	if(cachedRows==null)
    	{
    		try
    		{
				if(!countOnly)
	    		{
	    	        criteria.setLimit(-1).setOffset(0);
	    	    	String sql = adjustSelectSql(BasePeer.createQueryString(criteria));
	    		    cachedRows = executeSelect(sql);
	    		}	    		

				if(cachedRows==null) cachedRows = new ArrayList();
	
	            totalRowCount = cachedRows.size(); 
    		
			    if(countOnly)
			    {
	    	        criteria.setLimit(-1).setOffset(0);
	    	    	String sql = adjustSelectSql(BasePeer.createQueryString(criteria));
			        sql = makeCountSql(sql);
	                List countRows = executeSelect(sql);
	                Record countRow = (Record)countRows.get(0);   
	                totalRowCount = countRow.getValue(1).asInt();
			    }
    		}
		    catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
    	}
    }
            
// in java/org/tigris/scarab/search/CachedQuery.java
public void cacheAll()
	{
		if(cachedRows==null)
			cacheInitial();
		
    	if(cachedRowCount() < totalRowCount())
		{
    		try
    		{
		        criteria.setLimit(-1).setOffset(cachedRowCount());
		    	String sql = adjustSelectSql(BasePeer.createQueryString(criteria));
			    cachedRows.addAll(executeSelect(sql));
		    }
			catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
	        
		}
	}
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
public String getValue()
    {
        try
        {
            ScarabUser user = getScarabUser();
            if(user!=null)
                return user.getUserName();
            else
                return null;
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
public void setValue(final String username)  
    {
        try
        {
            if (username != null) 
                setUserIdOnly(
                    ScarabUserManager.getInstance(username).getUserId()
                );
            else
                setUserIdOnly(null);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public AttributeValue copy(Connection con) throws TorqueException 
    {
        throw new RuntimeException("Unimplemented method AttributeValue:copy(Connection conn)");
        //return copy();
    }
            
// in java/org/tigris/scarab/om/Activity.java
public String getNewValue(Issue issue, ScarabLocalizationTool l10n)
        throws Exception
    {
        String value = null;
        ActivityType activityType = getType();
        String newValue = getNewValue();
        
        if(   ActivityType.DEPENDENCY_CREATED.equals(activityType)
           || ActivityType.DEPENDENCY_CHANGED.equals(activityType))
        {
            if(newValue == null)
            {
                throw new RuntimeException("Dependency creation/change needs a new value. (Does imply that Dependency deletion is NOT supported?). The Error occured in issue " 
                          + issue.getParents()+ issue.getIdCount() );
            }
        	if(issue != null 
        			&& issue.getIssueId().intValue() != getDepend().getIssueRelatedByObservedId().getIssueId().intValue()
        			&& "blocking".equals(newValue))
        	{
            	value = getDepend().getIssueRelatedByObserverId().getUniqueId()
                + " " + l10n.get("DependsOn") //deprecated, but method is used many times in scarab.
            	+ " " + getDepend().getIssueRelatedByObservedId().getUniqueId(); 
            }
            else
            {
            	value = getDepend().getIssueRelatedByObservedId().getUniqueId()
            	+ " " + ("blocking".equals(newValue) ? l10n.get("PrerequisiteFor") : l10n.get(DependTypeManager.getManager().getL10nKey(newValue)))
                + " " + getDepend().getIssueRelatedByObserverId().getUniqueId();  
            }
        } 
        else if( ActivityType.ATTACHMENT_CREATED.equals(activityType))
        {
            value = getAttachment().getFileName();
        }
        else if(    ActivityType.URL_ADDED.equals(activityType)
                || ActivityType.COMMENT_ADDED.equals(activityType))
        {
            value = getAttachment().getData();
        }
        else if( ActivityType.COMMENT_CHANGED.equals(activityType))
        {
            value = newValue!=null ? firstChars( newValue, 50 ) : "";
        }
        else if( getType().equals(ActivityType.OTHER))
        {
            value = super.getDescription()!=null ? super.getDescription() : "";
        } 
        else 
        {
        	//assumption that an attribute was changed
        	if(getAttribute() != null && getAttribute().isDateAttribute())
        	{
        		value = DateAttribute.dateFormat(newValue!=null ? newValue : "",  L10NKeySet.ShortDateDisplay.getMessage(l10n));
        	}
        	else
        	{
        		value = newValue!=null ? newValue : "";
        	}            
        }
        return value;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public Integer getConditionOperator()
    {
        Integer operator = 0;
        List<Condition> conditions;
        try {
            conditions = getConditions();
        } catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        if(conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getAnonymousUser()
	    throws TorqueException
	{
		ScarabUser user = null;
	    if(anonymousAccessAllowed())
	    {
	        String username = getAnonymousUserName();
	        user = getInstance(username);
	    }
	    if (user == null)
	    {
	        try
	        {
	    	    user = (ScarabUser) TurbineSecurity.getAnonymousUser();
	        }
	        catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
	    }
	    return user;
	}
            
// in java/org/tigris/scarab/om/ScarabModule.java
public ScarabUser[] getUsers(List permissions)
    {
        ScarabUser[] result = null;
        Object obj = ScarabCache.get(this, GET_USERS, 
                                     (Serializable)permissions); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.setDistinct();
            if (permissions.size() == 1) 
            {
                crit.add(TurbinePermissionPeer.NAME, permissions.get(0));
            }
            else if (permissions.size() > 1)
            {
                crit.addIn(TurbinePermissionPeer.NAME, permissions);
            }      
            
            if (permissions.size() >= 1)
            {
                ArrayList groups = new ArrayList(2);
                groups.add(getModuleId());
                groups.add(ROOT_ID);
                crit.addJoin(TurbinePermissionPeer.PERMISSION_ID, 
                             TurbineRolePermissionPeer.PERMISSION_ID);
                crit.addJoin(TurbineRolePermissionPeer.ROLE_ID, 
                             TurbineUserGroupRolePeer.ROLE_ID);
                crit.addIn(TurbineUserGroupRolePeer.GROUP_ID, groups);
                crit.addJoin(ScarabUserImplPeer.USER_ID, 
                             TurbineUserGroupRolePeer.USER_ID);
                
                crit.add(ScarabUserImplPeer.getColumnName(User.CONFIRM_VALUE),(Object)ScarabUser.DELETED,Criteria.NOT_EQUAL);
                

                try
                {
                    User[] users = TurbineSecurity.getUsers(crit);
                    result = new ScarabUser[users.length];
                    for (int i=result.length-1; i>=0; i--) 
                    {
                        result[i] = (ScarabUser)users[i];
                    }
                }
                catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
            }
            else 
            {
                result = new ScarabUser[0];
            }
            ScarabCache.put(result, this, GET_USERS, 
                            (Serializable)permissions);
        }
        else 
        {
            result = (ScarabUser[])obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public Role getRequiredRole()
    {
        Role role = null;
        try
        {
            String roleName = GlobalParameterManager
               .getString(GlobalParameter.REQUIRED_ROLE_FOR_REQUESTING_ACCESS, this);
            if (roleName != null && roleName.length() > 0)
                role = TurbineSecurity.getRole(roleName);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
        return role;
    }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
public String getStatusLabel()
    {
        Integer status = getStatus();
        if (status.equals(WAIT)) return "wait";
        if (status.equals(SCHEDULED)) return "scheduled";
        if (status.equals(DEFERRED)) return "deferred";
        if (status.equals(FAIL)) return "fail";
        if (status.equals(SENT)) return "delivered";
        if (status.equals(MARK_DELETED)) return "deleted";
        if (status.equals(ON_HOLD)) return "onhold";
        throw new RuntimeException("Database inconsistency: status ["+status+"] is not known.");
    }
            
// in java/org/tigris/scarab/om/Transition.java
public Integer getConditionOperator()
    {
        Integer operator = 0;
        List<Condition> conditions;
        try {
            conditions = getConditions();
        } catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        if(conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public Integer getConditionOperator()
    {
        List<Condition> conditions;
        try {
            conditions = this.getConditions();
        } catch (TorqueException e) {
            throw new RuntimeException(e);
        }
        Integer operator = 0;
        if (conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void save(Connection dbCon)
        throws TorqueException
    {
        Module module = getModule();
        if (!module.allowsIssues() || (isNew() && !module.allowsNewIssues())) 
        {
            throw new UnsupportedOperationException(module.getName() + 
                " does not allow issues."); //EXCEPTION
        }
        
        // remove unset AttributeValues before saving
        List attValues = getAttributeValues();
        // reverse order since removing from list
        for (int i=attValues.size()-1; i>=0; i--) 
        {
            AttributeValue attVal = (AttributeValue) attValues.get(i);
            if (!attVal.isSet()) 
            {
                attValues.remove(i);
            }
        }

        if (isNew())
        {
            // set the issue id
            setIdDomain(module.getScarabInstanceId());
            setIdPrefix(module.getCode());

            // for an enter issue template, do not give issue id
            // set id count to -1 so does not show up as an issue
            if (isTemplate())
            { 
                setIdCount(-1);
            }
            else
            {
                try
                {
                    final int suggestedID = getIdCount();
                    if (suggestedID != 0) {
                        // Force the next available issue ID to be the
                        // nominated value, if not out of sequence.
                        // TODO: assert that this issue doesn't already exist
                        // In this case, just skip the next action.
                        setNextIssueId(dbCon, suggestedID);
                    }
                    
                    // Set the ID to the next available value.
                    setIdCount(getNextIssueId(dbCon));
                }
                catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        if(  getActivitySetRelatedByLastTransId()==null
           ||getActivitySetRelatedByCreatedTransId()==null)
        {
            throw new RuntimeException("Created or Last ActivitySet must not be null.");
        }
        super.save(dbCon);
    }
            
// in java/org/tigris/scarab/om/Issue.java
private void index()
    {
        try
        {
            SearchFactory.getInstance().index(this);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public Integer getConditionOperator()
    {
        Integer operator = 0;
        List<Condition> conditions;
        try {
            conditions = getConditions();
        } catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        if(conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
            
// in java/org/tigris/scarab/om/ModuleManager.java
public void addedObject(Persistent om)
    {
        try
        {
            if (om instanceof RModuleAttribute)
            {
                Module module = ((RModuleAttribute)om).getModule();
                getMethodResult().removeAll(module, AbstractScarabModule.GET_R_MODULE_ATTRIBUTES);
            }
            else if (om instanceof RModuleOption)
            {
                Module module = ((RModuleOption)om).getModule();
                getMethodResult().removeAll(module, AbstractScarabModule.GET_LEAF_R_MODULE_OPTIONS);
                getMethodResult().removeAll(module, AbstractScarabModule.GET_ALL_R_MODULE_OPTIONS);
            }
            else if (om instanceof RModuleIssueType) 
            {
                Module module = ((RModuleIssueType)om).getModule();
                getMethodResult().remove(module, AbstractScarabModule.GET_NAV_ISSUE_TYPES);
            }
            else if (om instanceof IssueType) 
            {
                getMethodResult().clear();
            }
            else if (om instanceof Attribute) 
            {
                getMethodResult().clear();
            }
            else if (om instanceof AttributeOption) 
            {
                getMethodResult().clear();
            }
            else if (om instanceof AttributeValue) 
            {
                Module module = ((AttributeValue)om).getIssue().getModule();
                getMethodResult().removeAll( module, ScarabModule.GET_DEFAULTREPORT);
            }
            else if (om instanceof Report) 
            {
                Module module = ((Report)om).getModule();
                if(module!=null)
                {
                    getMethodResult().removeAll(module, ScarabModule.GET_DEFAULTREPORT);
                }          
            }
        }
        catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private void createWakeupNotification(Issue issue, ScarabUser user, String wakeupMessage) throws TorqueException
    {
        Date date;
        try {
            date = issue.getOnHoldUntil();
        } catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            Activity activity = ActivityManager.getInstance();
            Attribute attribute = issue.getMyStatusAttribute();

            activity.setAttribute(attribute);
            activity.setActivityType(ActivityType.ISSUE_ONHOLD.getCode());
            activity.setDescription("WakeupFromOnHoldstate");
            activity.setIssue(issue);
            activity.setEndDate(date);
            activity.setNewValue("");
            activity.setOldValue("");
            activity.setOldOptionId(0);
            activity.setNewOptionId(0);
            
            Attachment attachment = AttachmentManager.getInstance();
            attachment.setTextFields(user, issue,Attachment.COMMENT__PK);
            attachment.setData(wakeupMessage);
            attachment.setName("comment");
            attachment.save();
            
            activity.setAttachment(attachment);
            
            Integer tt = ActivitySetTypePeer.EDIT_ISSUE__PK;
            ActivitySet activitySet;
            try {
                activitySet = ActivitySetManager.getInstance(tt, user);
                activitySet.addActivity(activity);
                activitySet.save();
                
                addActivityNotification(ActivityType.ISSUE_REMINDER, activitySet, issue, user);                
            } catch (ScarabException e) {
                throw new RuntimeException(e);
            }
    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
public void addOnHoldNotification(ActivitySet activitySet, Issue issue, ScarabUser user)
    {
        Date date;
        try {
            date = issue.getOnHoldUntil();
            Activity activity = ActivityManager.getInstance();
            Attribute attribute = issue.getMyStatusAttribute();
            activity.setAttribute(attribute);
            activity.setActivityType(ActivityType.ISSUE_ONHOLD.getCode());
            activity.setIssue(issue);
            activity.setEndDate(date);
            activity.setNewValue("GeneratedOnHoldState");
            activity.setOldValue("");
            activity.setOldOptionId(0);
            activity.setNewOptionId(0);
            activity.setDescription("GeneratedOnHoldState");
            activitySet.addActivity(activity);
            activitySet.save();
            NotificationStatus notification = new NotificationStatus(user, activity);
            notification.setStatus(NotificationStatus.ON_HOLD);
            NotificationStatusPeer.doInsert(notification);
        } catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
        
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public Integer[] getConditionsArray() 
    {
        Integer[] entries = new Integer[conditions.size()];
        Iterator<Condition> iter;
        try {
            iter = getConditions().iterator();
        } catch (TorqueException e) {
            throw new RuntimeException(e);
        }
        int index = 0;
        while(iter.hasNext())
        {
            Condition condition = iter.next();
            entries[index] = condition.getConditionId().intValue();
        }
        return entries;
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public Integer getConditionOperator()
    {
        Integer operator = 0;
        List<Condition> conditions;
        try {
            conditions = getConditions();
        } catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
        if(conditions.size() > 0)
        {
            operator = conditions.get(0).getOperator();
        }
        return operator;
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public boolean isConditioned()
    {
        boolean conditioned;
        try {
            conditioned = getConditions().size() > 0;
        } catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
        return conditioned;
    }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
private String createEntryTitle(Activity activity) {
        String displayName = null;
        try
        {
            displayName=activity.getDisplayName();
        }
        catch( Exception e)
        {
            throw new RuntimeException(e);
        }
		return displayName;
	}
            
// in java/org/tigris/scarab/actions/ConfigureReport.java
private void setNoPermissionMessage()
    {        
        if(scarabR==null | l10n==null){
            throw new RuntimeException("setup() method not called for action event");
        }
        scarabR.setAlertMessage(
            l10n.get(NO_PERMISSION_MESSAGE));
    }
            
// in java/org/tigris/scarab/actions/Login.java
public static void simpleLogin(RunData data, ScarabUser user)
    {
        if(user.getUserName().equals("")) //is it a TurbineAnonymousUser?
        {
        	user.setHasLoggedIn(Boolean.FALSE);
        }
        else
        {
        	user.setHasLoggedIn(Boolean.TRUE);
            try
            {
                user.updateLastLogin();
            }
            catch(Exception e)
            {
                throw new RuntimeException(e);
            }
        }
        data.setUser(user);
        data.save();
    }
            
// in java/org/tigris/scarab/actions/Login.java
public static void anonymousLogin(RunData data)
    {
    	ScarabUser anonymous = null;
    	try
        {
        	anonymous = ScarabUserManager.getAnonymousUser();
        }
        catch(Exception e)
        {
            throw new RuntimeException(e);
        }
        simpleLogin(data, anonymous);
    }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
private BuildLogger createLogger()
    {
        BuildLogger logger = null;
        if (loggerClassname != null)
        {
            try
            {
                logger = (BuildLogger) (Class.forName(loggerClassname)
                        .newInstance());
            }
            catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
            catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
        }
        else
        {
            logger = new DefaultLogger();
        }

        logger.setMessageOutputLevel(msgOutputLevel);
        logger.setOutputPrintStream(out);
        logger.setErrorPrintStream(err);
        logger.setEmacsMode(false);

        return logger;
    }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
public static final String urlEncode(String in)
    {
        try
        {
            return URLEncoder.encode(in, "UTF-8");
        }
        catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void cancelRebuild()
    {
        try
        {
            synchronized(this)
            {
                if(isRebuildInProgress())
                {
                    rebuildMonitor.cancel();
                    rebuildThread.join(10000);
                }
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void run()
        {
            try
            {
                Log.get().info(REBUILDING + "started");
                rebuild(this);
                Log.get().info(REBUILDING + "finished");
            }
            catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }            
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public void dispose()
    {
        try
        {
            synchronized(this)
            {
                cancelRebuild();
                close();
            }
        } 
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
        
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public Object get(int index)
        {
            Record next = (Record) queryResult.get(index);

            try
            {
	            Long issueId = new Long(next.getValue(1).asString());
	            Integer sortAttrId = getSortAttributeId();
	            Long sortValueId = null;
	            if(sortAttrId != null)
	            { 
	                String s = next.getValue(2).asString();
	                if(s!=null)
	                {
	                    sortValueId = new Long(s);	 
	                }                	 
	            }
	            return new QueryResult(issueId, issueListAttributeColumns, sortAttrId, sortValueId, L10N );
            }
            catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }
        }
32 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch(Exception e)
    		{
    			throw new RuntimeException(e);
    		}
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/attribute/UserAttribute.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    getLog().error(
                        "An exception prevented retrieving any users", e);
                    // this method should probably throw the exception, but
                    // until the interface is changed, wrap it in a RuntimeExc.
                    throw new RuntimeException(
                        "Please check turbine.log for more info: " + 
                        e.getMessage()); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (ScarabException e) {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
catch( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
            {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/actions/Login.java
catch(Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (ClassCastException e)
            {
                System.err
                        .println("The specified logger class " + loggerClassname
                                + " does not implement the BuildLogger interface");
                throw new RuntimeException();
            }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (Exception e)
            {
                System.err
                        .println("Unable to instantiate specified logger " + "class "
                                + loggerClassname
                                + " : "
                                + e.getClass().getName());
                throw new RuntimeException();
            }
            
// in java/org/tigris/scarab/util/ScarabUtil.java
catch ( Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
            {
                Log.get().error(REBUILDING + "failed", e);
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (Exception e)
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
catch (DataSetException e)
            {
                throw new RuntimeException(e);	
            }
0 4 
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (RuntimeException exc)
        {
            error = exc;
            throw exc;
        }
4 
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(Boolean.FALSE);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/xmlrpc/SimpleHandler.java
catch (RuntimeException e)
        {
            retValue.add(null);
            retValue.add(e);
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/actions/setup/AntRunner.java
catch (RuntimeException exc)
        {
            error = exc;
            throw exc;
        }
0
unknown (Lib) SAXException 0 0 7 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected void validate(final String name, 
            final Reader is,
            final BeanReader reader, 
            final Module currentModule)
        throws ParserConfigurationException,SAXException,IOException
    {
        // While parsing the XML, we perform well formed-ness and DTD
        // validation (if present, see Xerces dynamic feature).
        setValidationMode(reader, true);
        ScarabIssues si = null;
        try
        {
            si = (ScarabIssues) reader.parse(is);
        }
        catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }

        // If the XML is okay, validate the actual content.
        if (si != null)
        {
            // ASSUMPTION: Parse errors prevent entry into this block.
            validateContent(si, currentModule);

            // Log any errors encountered during import.
            if (importErrors != null)
            {
                final int nbrErrors = importErrors.size();
                LOG.error("Found " + nbrErrors + " error" +
                          (nbrErrors == 1 ? "" : "s") + " importing '" +
                          name + "':");
                for (Iterator itr = importErrors.iterator(); itr.hasNext(); )
                {
                    LOG.error(itr.next());
                }
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected ScarabIssues insert(
            final String name, 
            final Reader is, 
            final BeanReader reader)
        throws ParserConfigurationException,SAXException,IOException,ScarabException, TorqueException
    {
        setValidationMode(reader, false);
        final ScarabIssues si = (ScarabIssues)reader.parse(is);
        si.doHandleDependencies();
        LOG.debug("Successfully imported " + name + '!');
        return si;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private void setValidationMode(Digester reader, boolean state)
        throws ParserConfigurationException, SAXException
    {
        this.validationMode = state;

        // Setup the XML parser SAX2 features.

        // Turn on DTD validation (these are functionally equivalent
        // with Xerces 1.4.4 and likely most other SAX2 impls).
        reader.setValidating(state);
        reader.setFeature("http://xml.org/sax/features/validation", state);

        // Validate the document only if a grammar is specified
        // (http://xml.org/sax/features/validation must be state).
        reader.setFeature("http://apache.org/xml/features/validation/dynamic",
                          state);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected BeanReader createScarabIssuesBeanReader()
        throws ParserConfigurationException,IntrospectionException,SAXNotRecognizedException,
            SAXNotSupportedException
    {
        BeanReader reader = new BeanReader()
            {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }
            };

        // Connecting Digster's logger to ours logs too verbosely.
        //reader.setLogger(LOG);
        reader.register(SYSTEM_DTD_URI, INTERNAL_DTD_URI);
        // Be forgiving about the encodings we accept.
        reader.setFeature("http://apache.org/xml/features/allow-java-encodings",
                          true);
        reader.setXMLIntrospector(createXMLIntrospector());
        reader.registerBeanClass(ScarabIssues.class);
        NameMapper nm = reader.getXMLIntrospector().getNameMapper();
        reader.addRule(nm.mapTypeToElementName
                       (new BeanDescriptor(ScarabIssues.class).getName()),
                       new ScarabIssuesSetupRule());
        reader.setErrorHandler(this);
        return reader;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected void write(final Object bean, final Writer out)
        throws IOException,SAXException,IntrospectionException
    {
        final BeanWriter writer = new BeanWriter(out);
        writer.setXMLIntrospector(createXMLIntrospector());
        writer.enablePrettyPrint();
        writer.setWriteIDs(false);
        writer.write(bean);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader insertModuleNode(final Reader result, 
            final Module currModule) 
        throws TorqueException, JDOMException, IOException, TransformerException 
    {
        
        final ScarabUser user = ScarabUserManager.getInstance(currModule.getOwnerId());        
        
        // Core Java: org.w3c.dom version (jdk1.4+ compatible)
//        final DocumentBuilder docBuilder = documentBuilderFactory.newDocumentBuilder();
//        final Document doc = docBuilder.parse( new InputSource(result) );
//        // insert module
//        final Element root = doc.getDocumentElement();
//        final Element moduleNode = doc.createElement("module");
//        final Element idNode = doc.createElement("id");
//        final Element parentIdNode = doc.createElement("parent-id");
//        final Element nameNode = doc.createElement("name");
//        final Element ownerNode = doc.createElement("owner");
//        final Element descriptionNode = doc.createElement("description");
//        final Element urlNode = doc.createElement("url");
//        final Element domainNode = doc.createElement("domain");
//        final Element codeNode = doc.createElement("code");
//        
//        idNode.appendChild(doc.createTextNode(String.valueOf(currModule.getModuleId())));
//        parentIdNode.appendChild(doc.createTextNode(String.valueOf(currModule.getParentId())));
//        nameNode.appendChild(doc.createTextNode(currModule.getName()));
//        ownerNode.appendChild(doc.createTextNode(user.getUserName()));
//        descriptionNode.appendChild(doc.createTextNode(currModule.getDescription()));
//        urlNode.appendChild(doc.createTextNode(currModule.getUrl()));
//        domainNode.appendChild(doc.createTextNode(currModule.getHttpDomain()));
//        codeNode.appendChild(doc.createTextNode(currModule.getCode()));
//        
//        moduleNode.appendChild(idNode);
//        moduleNode.appendChild(parentIdNode);
//        moduleNode.appendChild(nameNode);
//        moduleNode.appendChild(ownerNode);
//        moduleNode.appendChild(descriptionNode);
//        moduleNode.appendChild(urlNode);
//        moduleNode.appendChild(domainNode);
//        moduleNode.appendChild(codeNode);
//        
//        root.appendChild(moduleNode);
        
        // JDom version (jdk1.3 compatible)
        
        final SAXBuilder builder = new SAXBuilder();
        builder.setEntityResolver(new EntityResolver()
        {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }   
        });
        final Document doc = builder.build(result);        
        final Element root = doc.getRootElement();

        final Element moduleNode = new Element("module");
        final Element idNode = new Element("id");
        final Element parentIdNode = new Element("parent-id");
        final Element nameNode = new Element("name");
        final Element ownerNode = new Element("owner");
        final Element descriptionNode = new Element("description");
        final Element urlNode = new Element("url");
        final Element domainNode = new Element("domain");
        final Element codeNode = new Element("code");    
        
        idNode.setText(String.valueOf(currModule.getModuleId()));
        parentIdNode.setText(String.valueOf(currModule.getParentId()));
        nameNode.setText(currModule.getRealName());
        ownerNode.setText(user.getUserName());
        descriptionNode.setText(currModule.getDescription());
        urlNode.setText(currModule.getUrl());
        domainNode.setText(currModule.getHttpDomain());
        codeNode.setText(currModule.getCode());
        
        moduleNode.addContent(idNode)
                .addContent(parentIdNode)
                .addContent(nameNode)
                .addContent(ownerNode)
                .addContent(descriptionNode)
                /*
                 * These are excluded for now, since your database domain may 
                 * not correspond to currModule.getHttpDomain().
                .addContent(urlNode)
                .addContent(domainNode)
                 */
                .addContent(codeNode);
        root.addContent(2,moduleNode);
        
        return transformXML(new JDOMSource(doc), null, currModule, null);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private InputSource resolveEntity(
            final EntityResolver reader,
            final String publicId,
            final String systemId)
        throws SAXException
    {
        InputSource input = null;
        if (publicId == null && systemId != null)
        {
            // Resolve SYSTEM DOCTYPE.
            if (SYSTEM_DTD_URI.equalsIgnoreCase(systemId) ||
                INTERNAL_DTD_URI.equalsIgnoreCase(systemId))
            {
                // First look for the DTD in the classpath.
                input = resolveDTDResource();

                if (input == null)
                {
                    try {
                        // Kick resolution back to Digester.
                        input = reader.resolveEntity(publicId, systemId);
                    
                    } catch (IOException ex) {
                        LOG.error(ex);
                    }
                }
            }
        }
        return input;
    }
2 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
0
unknown (Lib) SAXParseException 0 0 2 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public void error(SAXParseException e)
        throws SAXParseException
    {
        LOG.error("Parse Error at line " + e.getLineNumber() +
                  " column " + e.getColumnNumber() + ": " + e.getMessage(), e);
        throw e; //EXCEPTION
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public void fatalError(SAXParseException e)
        throws SAXParseException
    {
        LOG.error("Parse Fatal Error at line " + e.getLineNumber() +
                  " column " + e.getColumnNumber() + ": " + e.getMessage(), e);
        throw e; //EXCEPTION
    }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXParseException e)
        {
            // TODO: L10N this error message from Xerces (somehow),
            // and provide a prefix that describes that a XML parse
            // error was encountered.
            String message = new String("XML parse error at line " + e.getLineNumber() +
                             " column " + e.getColumnNumber() + ": " +
                             e.getMessage());
            LOG.error(message);
            importErrors.add(message);
        }
0 0
unknown (Domain) ScarabException 
public class ScarabException extends TurbineException //implements Localizable
{
    /**
     * The exception message in non-localized form.
     * Further infos, see the {@link #getMessage(L10N) getmessage } methods below.
     */
    private Localizable l10nMessage;
    

    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * resource and no parameters.
     * @param theKey the l10n error key.
     */
    public ScarabException(LocalizationKey theKey)
    {
         l10nMessage = new L10NMessage(theKey);
    }

    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * resource and a nested Throwable.
     * @param theKey the l10n error key.
     * @param nested
     */
    public ScarabException(LocalizationKey theKey, Throwable nested)
    {
        super(nested);
        l10nMessage = new L10NMessage(theKey, nested);
    }


    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * Localizable .
     * @param theL10nInstance the l10n error key.
     */
    public ScarabException(Localizable theL10nInstance)
    {
         l10nMessage = theL10nInstance;
    }
 
    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * Localizable and a nested Throwable.
     * @param theL10nInstance the l10n error key.
     * @param nested
     */
    public ScarabException(Localizable theL10nInstance, Throwable nested)
    {
        super(nested);
        l10nMessage = theL10nInstance;
    }

    
    /**
     * Constructs a new <code>ScarabException</code> with specified 
     * resource and a list of parameters.
     * @param theL10nInstance the l10n error key.
     * @param theParams
     */
    public ScarabException (LocalizationKey theKey, Object[] theParams)
    {
        l10nMessage = new L10NMessage(theKey, theParams);
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and one parameter.
     * @param theL10nInstance the l10n error key.
     * @param p1
     */
    public ScarabException (LocalizationKey theKey, Object p1)
    {
        this(theKey, new Object[] {p1});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and two parameters.
     * @param theL10nInstance the l10n error key.
     * @param p1
     * @param p2
     */
    public ScarabException (LocalizationKey theKey, Object p1, Object p2)
    {
        this(theKey, new Object[] {p1, p2});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and three parameters.
     * @param theL10nInstance the l10n error key.
     * @param p1
     * @param p2
     * @param p3
     */
    public ScarabException (LocalizationKey theKey, Object p1, Object p2, Object p3)
    {
        this(theKey, new Object[] {p1, p2, p3});
    }
  

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and an aritrary set of parameters.
     * 
     * @param theKey
     * @param nested
     * @param theParams
     */
    public ScarabException (LocalizationKey theKey, Throwable nested, Object[] theParams)
    {
        this(new L10NMessage(theKey, theParams),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and one parameter.
     * @param theKey
     * @param nested
     * @param p1
     */
    public ScarabException (LocalizationKey theKey, Throwable nested, Object p1)
    {
        this(new L10NMessage(theKey, p1),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and two parameters.
     * @param theKey
     * @param nested
     * @param p1
     * @param p2
     */
    public ScarabException (LocalizationKey theKey, Throwable nested, Object p1, Object p2)
    {
        this(new L10NMessage(theKey, p1, p2),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and three parameters.
     * @param theKey
     * @param nested
     * @param p1
     * @param p2
     * @param p3
     */
    public ScarabException (LocalizationKey theKey, Throwable nested, Object p1, Object p2, Object p3)
    {
        this(new L10NMessage(theKey, p1, p2, p3),nested);
    }

    /**
     * return the L10NInstance, or null, if no L10N key was given.
     * @return
     */
    public Localizable getL10nMessage()
    {
        return l10nMessage;
    }
    
    /** 
     * return the localized message by use of the
     * given ScarabLocalizationTool. For further infos see
     * {@link #getMessage() getMessage }
     *
     * @deprecated Does not follow core java patterns. Use setLocalizer(..) then getLocalizedMessage() instead.
     *
     * @param l10n
     * @return
     */
    public String getMessage(final ScarabLocalizationTool l10n)
    {
        return (l10nMessage==null)
            ? super.getMessage()
            : l10nMessage.getMessage(l10n);
    }
 
    /**
     * return the localized message in english.
     * Note: It is preferrable to use 
     * {@link #getMessage(ScarabLocalizationTool) getMessage }
     * Currently it is possible, that a ScarabException
     * contains NO L10NInstance. This is due to the deprecated
     * constructors {@link #ScarabException() ScarabException }
     * and {@link #ScarabException(String) ScarabException }
     * Eventually (after these constructors have been deleted
     * from the code base) we guarantee, that ScarabException 
     * is fully localized.
     *
     * @return localized english text
     */
    public String getMessage()
    {
        return (l10nMessage==null)
            ? super.getMessage()
            : l10nMessage.getMessage();
    }

    /**
     * Holds value of property localizer.
     */
    private ScarabLocalizationTool localizer;

    /**
     * Setter for property l10n.
     * @param l10n New value of property l10n.
     */
    public void setLocalizer(final ScarabLocalizationTool localizer)
    {

        this.localizer = localizer;
    }

    public String getLocalizedMessage()
    {
        return (l10nMessage==null)
            ? super.getMessage()
            : (localizer == null)
                ? l10nMessage.getMessage()
                : l10nMessage.getMessage(localizer);
    }
}
 		83 
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Object getSessionAttribute(String key) throws ScarabException
    {
        HttpSession session = data.getSession();
        Object value;
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        value = session.getAttribute(key);
        return value;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean hasSessionAttribute(String key) throws ScarabException
    {
        HttpSession session = data.getSession();
        Object value;
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        value = session.getAttribute(key);
        return value != null;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean setSessionAttribute(String key, Object value) throws ScarabException
    {
        HttpSession session = data.getSession();
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        session.setAttribute(key,value);
        return true;
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setChainedValue(final AttributeValue  v)
        throws TorqueException, ScarabException
    {
        if (v == null)
        {
            this.chainedValue = null;
        }
        else 
        {        
            if (v.getAttributeId() == null && getAttributeId() != null) 
            {
                v.setAttributeId(getAttributeId());
            }
            else if (v.getAttribute() != null 
                     && !v.getAttribute().equals(getAttribute()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainAttributeValues,
                                          v.getAttributeId(),
                                          getAttributeId());
            }
            
            if (v.getIssueId() == null && getIssueId() != null) 
            {
                v.setIssueId(getIssueId());
            }
            else if (v.getIssue() != null 
                      && !v.getIssue().equals(getIssue()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainIssues,
                                          v.getIssueId(),
                                          getIssueId());
            }

            if (this.chainedValue == null) 
            {
                this.chainedValue = v;
            }
            else 
            {
                chainedValue.setChainedValue(v);
            }
            
            if (activitySet != null) 
            {
                v.startActivitySet(activitySet);
            }        
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void startActivitySet(ActivitySet activitySet)
        throws ScarabException, TorqueException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionCanNotStartActivitySet);
        }
        
        if (this.activitySet == null) 
        {
            this.activitySet = activitySet;
        }
        else
        {
            throw new ScarabException(L10NKeySet.ExceptionActivitySetInProgress);
        }
/*
This is wrong. It prevented the old/new value stuff from working properly!
If we have an existing issue and we change some attributes, then when the
history was created, the data was not valid in it for some reason. I'm not
quite sure why this was added. (JSS)

Leaving here so that John can remove or fix.

        oldOptionIdIsSet = false;
        oldValueIsSet = false;
        oldOptionId = null;
        oldValue = null;
*/

        // Check for previous active activities on this attribute 
        // If they exist, set old value for this activity
        List result = null;
        final Issue issue = getIssue();
        if (issue != null)
        {
            result = issue
                .getActivitiesWithNullEndDate(getAttribute());
        }
        if (result != null && result.size() > 0)
        {
            for (int i=0; i<result.size(); i++)
            {
                final Activity a = (Activity)result.get(i);
                oldOptionId = a.getNewOptionId();
                oldValue = a.getNewValue();
            }
        }
        if (chainedValue != null) 
        {
            chainedValue.startActivitySet(activitySet);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
private void checkActivitySet(LocalizationKey l10nKey)
        throws ScarabException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(l10nKey);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public Integer[] getUserIds()
        throws ScarabException
    {
        throw new ScarabException(L10NKeySet.ExceptionGetUserIdsNotImplemented);
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public RModuleAttribute getRModuleAttribute()
        throws TorqueException, ScarabException
    {
        final Issue issue = getIssue();
        RModuleAttribute rma = null;
        if (issue != null)
        {
            final Module module = issue.getModule();
            if (module != null)
            {
                rma = module.getRModuleAttribute(
                    getAttribute(), getIssue().getIssueType());
            }
            else
            {
                throw new ScarabException (L10NKeySet.ExceptionGeneral,
                        "Module is null: Please report this issue."); //EXCEPTION
            }
        }
        else
        {
            throw new ScarabException (L10NKeySet.ExceptionGeneral,
                    "Issue is null: Please report this issue."); //EXCEPTION
        }
        return rma;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonLeafRModuleOptions(final Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getLeafRModuleOptions(
                attribute,
                item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleOptionTree(Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getOptionTree(attribute, item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }  
        catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
    }
            
// in java/org/tigris/scarab/om/Query.java
public boolean saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped query, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        Exception exception=null; // temporary store a thrown exception

        if (getScopeId().equals(Scope.PERSONAL__PK) 
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        }
        else
        {
            setApproved(false);

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");

                final ScarabUser[] toUsers = module
                    .getUsers(ScarabSecurity.ITEM__APPROVE);

                if (Log.get().isDebugEnabled()) 
                {
                    if (toUsers == null || toUsers.length ==0) 
                    {
                        Log.get().debug("No users to approve query.");    
                    }
                    else 
                    {
                        Log.get().debug("Users to approve query: ");    
                        for (int i=0; i<toUsers.length; i++) 
                        {
                            Log.get().debug(toUsers[i].getEmail());
                        }  
                    }          
                }
                
                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewQueryRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx,
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null,
                        template);
                }
                catch (Exception e)
                {
                    exception = e;
                }
            }
        }
        if (getMITList() != null) 
        {
            getMITList().save();
            // it would be good if this updated our list id, but it doesn't
            // happen automatically so reset it.
            setMITList(getMITList());            
        }
        save();
        if(exception != null)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral, exception);
        }
        return true;
    }
            
// in java/org/tigris/scarab/om/Query.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/Query.java
public void delete(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module)
          || (user.getUserId().equals(getUserId()) 
             && getScopeId().equals(Scope.PERSONAL__PK)))
        {
            // Delete user-query maps.
            final List rqus = getRQueryUsers();
            for (int i=0; i<rqus.size(); i++)
            {
                final RQueryUser rqu = (RQueryUser)rqus.get(i);
                rqu.delete(user);
            }
            setDeleted(true);
            save();
            
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
                                          final ScarabUser user, 
                                          final Attachment attachment)
        throws TorqueException,ScarabException
    {
        if (attachment != null && attachment.getAttachmentId() == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNeedToSaveAttachement);
        }
        final ActivitySet activitySet = new ActivitySet();
        activitySet.setTypeId(typeId);
        activitySet.setCreatedBy(user.getUserId());
        activitySet.setCreatedDate(new Date());
        if (attachment != null && 
            attachment.getData() != null &&
            attachment.getData().length() > 0)
        {
            activitySet.setAttachment(attachment);
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
protected void delete(final boolean overrideLock)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        final IssueType issueType = IssueTypeManager
           .getInstance(getIssueTypeId(), false);
        if (issueType.getLocked() && !overrideLock)
        { 
            throw new ScarabException(L10NKeySet.CannotDeleteAttributeFromLockedIssueType);
        }            
        else
        {
            final Criteria c = new Criteria()
                .add(RModuleAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleAttributePeer.doDelete(c);
            final Attribute attr = getAttribute();
            String attributeType = null;
            attributeType = (attr.isUserAttribute() ? Module.USER : Module.NON_USER);
            module.getRModuleAttributes(getIssueType(), false, attributeType)
                                        .remove(this);
            WorkflowFactory.getInstance().deleteWorkflowsForAttribute(
                                          attr, module, getIssueType());

            // delete module-user-attribute mappings
            final Criteria crit = new Criteria()
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attr.getAttributeId())
                .add(RModuleUserAttributePeer.MODULE_ID, 
                     getModuleId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                     getIssueTypeId());
            RModuleUserAttributePeer.doDelete(crit);

            // delete module-option mappings
            if (attr.isOptionAttribute())
            {
                final List optionList = module.getRModuleOptions(attr, 
                                  IssueTypePeer.retrieveByPK(getIssueTypeId()), 
                                  false);
                if (optionList != null && !optionList.isEmpty())
                {
                    final List optionIdList =
                        new ArrayList(optionList.size());
                    for (int i = 0; i < optionList.size(); i++)
                    { 
                        optionIdList.add(((RModuleOption)
                                          optionList.get(i))
                                         .getOptionId());
                    }
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID, getModuleId())
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,
                             getIssueTypeId())
                        .addIn(RModuleOptionPeer.OPTION_ID, optionIdList);
                    RModuleOptionPeer.doDelete(c2);
                }
            }
        }

        RModuleAttributeManager.removeInstanceFromCache(this);
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public void delete()
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

            final IssueType issueType = IssueTypeManager
               .getInstance(getIssueTypeId(), false);
            if (issueType.getLocked())
            { 
                throw new ScarabException(L10NKeySet.ExceptionDeleteOptionFromLockedIssueType);
            }            
            else
            {
                Integer moduleId    = getModuleId();
                Integer issueTypeId = getIssueTypeId();
                Integer optionId    = getOptionId();
                int orderNumber     = getOrder();

                // delete the option
                final Criteria c = new Criteria()
                    .add(RModuleOptionPeer.MODULE_ID, moduleId)
                    .add(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId)
                    .add(RModuleOptionPeer.OPTION_ID, optionId);
                RModuleOptionPeer.doDelete(c);
                
                // delete associated workflow
                WorkflowFactory.getInstance().deleteWorkflowsForOption(getAttributeOption(), 
                                             module, issueType);

                // ======================================================
                // Correct the ordering of the remaining options
                // ======================================================

                // first retrieve the list of still available option ids
                final List optIds = new ArrayList();
                final List rmos = module.getRModuleOptions(getAttributeOption().getAttribute(), issueType, false);
                for (int i=0; i<rmos.size();i++)
                {
                    final RModuleOption rmo = (RModuleOption)rmos.get(i);
                    optIds.add(rmo.getOptionId());
                }
               
                // Need to perform the correction only if the deleted option had follow up options
                if(optIds.size() > 0)
                {
                    // update the list
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID,       moduleId)
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,   issueTypeId)
                        .addIn(RModuleOptionPeer.OPTION_ID,     optIds)
                        .add(RModuleOptionPeer.PREFERRED_ORDER, orderNumber, Criteria.GREATER_THAN);
                    final List adjustRmos = RModuleOptionPeer.doSelect(c2);
                    for (int j=0; j<adjustRmos.size();j++)
                    {
                        final RModuleOption rmo = (RModuleOption)adjustRmos.get(j);
                        //rmos.remove(rmo);
                        rmo.setOrder(rmo.getOrder() -1);
                        rmo.save();
                        //rmos.add(rmo);
                    }
                }
            }
            // notify module cache of this change
            ((ModuleManager)Torque.getManager(ModuleManager.MANAGED_CLASS))
                .refreshedObject(this);
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected ScarabUser getInstanceByEmailImpl(final String email) 
        throws TorqueException,ScarabException
    {
        ScarabUser user = null;
        if (email != null) 
        {
            final Criteria crit = new Criteria();
            crit.add(ScarabUserImplPeer.EMAIL, email);
            final List users = ScarabUserImplPeer.doSelect(crit);
            if (users.size() == 1) 
            {
                user = (ScarabUser)users.get(0);
            }
            else if (users.size() > 1) 
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateUsername); 
            }
        }
        return user;
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public void save()
        throws TorqueException, ScarabException
    {
        AttributeOption ao = null;
        ROptionOption roo = null;

        final Attribute tmpAttr = AttributeManager.getInstance(getAttributeId());
        
        // if it is new, it won't already have an optionId
        if (getOptionId() == null)
        {
            // if it is new, check for duplicates.
            final AttributeOption duplicate = 
                AttributeOptionManager.getInstance(tmpAttr, getName().trim());
            final AttributeOption parent = 
                AttributeOptionManager.getInstance(getParentId());
            if (duplicate != null)
            {
                throw new ScarabException (new L10NKey("CannotCreateDuplicateOption")); //EXCEPTION
            }
            else if (parent.getDeleted())
            {
                throw new ScarabException (new L10NKey("CannotCreateChild")); //EXCEPTION
            }
        }

        // if getOptionId() is null, then it will just create a new instance
        final Integer optionId = getOptionId();
        if (optionId == null)
        {
            ao = AttributeOptionManager.getInstance();
        } 
        else
        {
            ao = AttributeOptionManager.getInstance(getOptionId());
        }

        
        ao.setName(getName());
        ao.setDeleted(getDeleted());
        ao.setAttribute(tmpAttr);
        ao.setStyle(getStyle());
        ao.save();

        // clean out the caches for the AO
        tmpAttr.doRemoveCaches();

        // now set our option id from the saved AO
        this.setOptionId(ao.getOptionId());

        // now create the ROO mapping
        try
        {
            // look for a cached ROptionOption
            roo = ROptionOption.getInstance(getParentId(), getOptionId());
        }
        catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
        roo.setPreferredOrder(getPreferredOrder());
        roo.setWeight(getWeight());
        roo.setRelationshipId(OptionRelationship.PARENT_CHILD);
        roo.save();
    }
            
// in java/org/tigris/scarab/om/ROptionOption.java
public static ROptionOption getInstance(final Integer parent, final Integer child)
        throws ScarabException
    {
    	ROptionOption option = null;
    	try
        {
    	    final Criteria crit = new Criteria();
            crit.add (ROptionOptionPeer.OPTION1_ID, parent);
            crit.add (ROptionOptionPeer.OPTION2_ID, child);
            option = (ROptionOption) (ROptionOptionPeer.doSelect(crit)).get(0);
        }
        catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
        return option;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public IssueType getTemplateIssueType()
        throws TorqueException, ScarabException
    {
        if (templateIssueType == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.PARENT_ID, getIssueTypeId());
            final List results = IssueTypePeer.doSelect(crit);
            if (results.isEmpty())
            {
                throw new ScarabException(L10NKeySet.ExceptionTemplateTypeForIssueType);
            }
            else
            {
                templateIssueType = (IssueType)results.get(0);
            }
        }
        return templateIssueType;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public static IssueType getInstance(final String issueTypeName)
        throws TorqueException,ScarabException
    {
        IssueType result = null;
        Object obj = ScarabCache.get(ISSUE_TYPE, GET_INSTANCE, issueTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.NAME, issueTypeName);
            final List issueTypes = IssueTypePeer.doSelect(crit);
            if(issueTypes == null || issueTypes.size() == 0)
            {
                throw new ScarabException(L10NKeySet.ExceptionInvalidIssueType,
                                          issueTypeName);
            }
            result = (IssueType)issueTypes.get(0);
            ScarabCache.put(result, ISSUE_TYPE, GET_INSTANCE, issueTypeName);
        }
        else 
        {
            result = (IssueType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user)
        throws ScarabException
    {
        int count = 0;
        try 
        {
            IssueSearch is = IssueSearchFactory.INSTANCE
                .getInstance(getModule(), getIssueType(), user);
            count = is.getIssueCount();
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
        return count;
    }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(NotificationStatus notif) throws ScarabException
    {
        NotificationRule rule = null;
        try
        {
            Long issueId = notif.getIssueId();
            Issue issue = IssueManager.getInstance(issueId);
            Integer moduleId = issue.getModuleId();
            Integer userId = notif.getReceiverId();
            ActivityType activityType = notif.getActivityType();
            rule = getNotificationRule(moduleId, userId, activityType.getCode());
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
        return rule;
    }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(Integer moduleId, Integer userId, String activityType) throws ScarabException
    {
        NotificationRule rule = null;
        
        int managerId = NotificationManagerFactory.getInstance().getManagerId();
        Criteria crit = new Criteria();
        crit.add(NotificationRulePeer.USER_ID, userId);
        crit.add(NotificationRulePeer.MODULE_ID, moduleId);
        crit.add(NotificationRulePeer.ACTIVITY_TYPE, activityType);
        crit.add(NotificationRulePeer.MANAGER_ID, managerId);
                
        try
        {
            List<NotificationRule> ruleSet = (List<NotificationRule>)NotificationRulePeer.doSelect(crit);     
            if(ruleSet == null || ruleSet.size()==0)
            {

                rule = NotificationRule.createDefaultRule( 
                       moduleId, 
                       userId,
                       managerId,
                       activityType);
            }
            else if (ruleSet.size() > 1)
            {
                String msg = "Database inxonsistency:"
                           + " Expected at most one key matching (user_id,module_id,activity_type,manager_id) = "
                           + ")" + userId + "," + moduleId + "," + activityType + "," + managerId + ")";
                throw new TorqueException(msg,new Throwable());
            }
            else
            {
                rule = ruleSet.get(0);
            }
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }

        return rule;
    }
            
// in java/org/tigris/scarab/om/RIssueTypeOption.java
public void delete(final ScarabUser user, final Module module)
         throws TorqueException, ScarabException
    {                
        if (user.hasPermission(ScarabSecurity.DOMAIN__EDIT, module))
        {
            final List rios = getIssueType().getRIssueTypeOptions(
                                      getAttributeOption().getAttribute(), false);
            final Criteria c = new Criteria()
                .add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
            RIssueTypeOptionPeer.doDelete(c);
            rios.remove(this);
            if (rios.size() > 0)
            {
                // Correct the ordering of the remaining options
                final ArrayList optIds = new ArrayList();
                for (int i=0; i<rios.size();i++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)rios.get(i);
                    optIds.add(rio.getOptionId());
                }
                final Criteria c2 = new Criteria()
                    .addIn(RIssueTypeOptionPeer.OPTION_ID, optIds)
                    .add(RIssueTypeOptionPeer.PREFERRED_ORDER, getOrder(), 
                         Criteria.GREATER_THAN);
                final List adjustRios = RIssueTypeOptionPeer.doSelect(c2);
                for (int j=0; j<adjustRios.size();j++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)adjustRios.get(j);
                    rio.setOrder(rio.getOrder() -1);
                    rio.save();
                }
            }
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public ScarabUser[] getEligibleUsers(Attribute attribute)
        throws TorqueException,ScarabException
    {
        ScarabUser[] users = null;
        if (attribute.isUserAttribute()) 
        {
            String permission = attribute.getPermission();
            if (permission == null) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionNoAttributePermission,
                        attribute.getName());
            }
            else 
            {
                users = getUsers(permission);
            }
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getSavedReports(final ScarabUser user)
        throws TorqueException,ScarabException
    {
        List reports = null;
        final Object obj = ScarabCache.get(this, GET_SAVED_REPORTS, user); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria()
                .add(ReportPeer.DELETED, 0);
            final Criteria.Criterion cc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.MODULE__PK, Criteria.EQUAL);
            cc.and(crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL));
            final Criteria.Criterion personalcc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.PERSONAL__PK, Criteria.EQUAL);
            personalcc.and(crit.getNewCriterion(
                ReportPeer.USER_ID, user.getUserId(), Criteria.EQUAL));
            final Criteria.Criterion personalmodulecc = crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL);
            personalmodulecc.or(crit.getNewCriterion(
                ReportPeer.MODULE_ID, null, Criteria.EQUAL));
            personalcc.and(personalmodulecc);
            cc.or(personalcc);
            crit.add(cc);
            crit.addAscendingOrderByColumn(ReportPeer.SCOPE_ID);
            final List torqueReports = ReportPeer.doSelect(crit);      
            // create ReportBridge's from torque Reports.
            if (!torqueReports.isEmpty()) 
            {
                reports = new ArrayList(torqueReports.size());
                for (Iterator i = torqueReports.iterator(); i.hasNext();) 
                {
                    final Report torqueReport = (Report)i.next();
                    try 
                    {
                        reports.add( new ReportBridge(torqueReport) );
                    }
                    catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }     
                    catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
                }
            }
            else 
            {
                reports = Collections.EMPTY_LIST;
            }

            ScarabCache.put(reports, this, GET_SAVED_REPORTS, user);
        }
        else 
        {
            reports = (List)obj;
        }
        return reports;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/ActivitySetTypeManager.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException,ScarabException
    {
        ActivitySetType ttype = null; 
        Object obj = ScarabCache.get(TRANSACTION_TYPE, GET_INSTANCE, 
                                     activitySetTypeName);
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(ActivitySetTypePeer.NAME, activitySetTypeName);
            final List activitySetTypes = ActivitySetTypePeer.doSelect(crit);
            if (activitySetTypes.size() < 1) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetTypenameNotFound, 
                        activitySetTypeName);
            }
            if (activitySetTypes.size() > 1)
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetDuplicateTypename,
                        activitySetTypeName);
            }
            ttype = (ActivitySetType)activitySetTypes.get(0);
            ScarabCache.put(ttype, "ActivitySetType", "getInstance", 
                            activitySetTypeName);
        }
        else 
        {
            ttype = (ActivitySetType)obj;
        }
        
        return ttype;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(ActivitySet activitySet, 
                                  Attachment attachment, ScarabUser user)
        throws TorqueException, ScarabException
    {
        String comment = attachment.getData();
        if (comment == null || comment.length() == 0)
        {
            throw new ScarabException(L10NKeySet.NoDataInComment);
        }

        activitySet = attachActivitySet(activitySet, user);

        // populates the attachment with data to be a comment
        attachment = AttachmentManager
                        .getComment(attachment, this, user);

        ActivityManager
            .createTextActivity(this, activitySet,
                                ActivityType.COMMENT_ADDED, attachment);

        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.COMMENT_ADDED, activitySet, this, user);            

        index();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doAddDependency(ActivitySet activitySet, Depend depend, 
                                       Issue childIssue, ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check whether the entered issue is already dependent on this
        // Issue. If so, then throw an exception because we don't want
        // to add it again.
        Depend prevDepend = this.getDependency(childIssue, true);
        if (prevDepend != null)
        {
            throw new ScarabException(L10NKeySet.DependencyExists);
        }

        // we definitely want to do an insert here so force it.
        depend.setNew(true);
        depend.setDeleted(false);
        depend.save();

        Attachment comment = depend.getDescriptionAsAttachment(user, this);
        activitySet = attachActivitySet(activitySet, user, comment);

        // Save activity record for the parent issue
        ActivityManager
            .createAddDependencyActivity(this, activitySet, depend);

        // Save activity record for the child issue
        ActivityManager
            .createAddDependencyActivity(childIssue, activitySet, depend);

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private int getNextIssueId(Connection con)
        throws TorqueException, ScarabException
    {
        int id = -1;
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        try
        {
            id = idbroker.getIdAsInt(con, key);
        }
        catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
        return id;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private void setNextIssueId(Connection con, int newID)
        throws TorqueException, ScarabException
    {
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        int nextID = 1;
        
        synchronized (idbroker)
        {
            try
            {
                // Check if the ID table is available and get the next ID
                nextID = idbroker.getIdAsInt(con, key);
            }
            catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }

            if (nextID > newID) {
                getLog()
                    .error("New issue ID "+ newID
                    + "is out of sequence. Must be at least " + nextID);
            }
            else
            {
                try
                {
                    // Now set the next available ID in the table
                    setIdTableKey(con, newID);
                }
                catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Issue move(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user,
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
    	
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // If moving to a new issue type, just change the issue type id
        // otherwise, create fresh issue
        if (getModule().getModuleId().equals(newModule.getModuleId())
            && !getIssueType().getIssueTypeId().equals(newIssueType.getIssueTypeId()))
        {
            newIssue = this;
            newIssue.setIssueType(newIssueType);
            newIssue.save();
        }
        else
        {
            newIssue = newModule.getNewIssue(newIssueType);
        }

        if (newIssue != this)//new issue is not same issue instance as old issue
        {
            // mark issue as moved
            setMoved(true);
            save();

            //add new transaction to new issue
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();      

            // copy attachments: comments/files etc.
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                String oldFilePath = oldA.getFullPath();
                oldA.setIssueId(newIssue.getIssueId());
                oldA.save();
                
                // move file attachment, too
                if (Attachment.FILE__PK.equals(oldA.getTypeId())
                		&& !newIssue.getUniqueId().equals(this.getUniqueId()))
                {
                    try
                    {
                        oldA.copyFileFromTo(oldFilePath, oldA.getFullPath());//copy
                        File f = new File(oldFilePath);//delete old one from disk
                        f.delete();
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }

            // Copy over activity sets for the source issue's previous,
            // and adapt them to new issue
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();

                // If activity set has an attachment, make a copy for new issue
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    // iterate over and move transaction's activities
                    final Activity a = (Activity)j.next();
                    
                    // Only copy transactions that are records of previous move/copies
                    // or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // will be saved when attachments and dependencies are copied.
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                            || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                    	att.setIssueId(newIssue.getIssueId());
                                    	att.setActivity(a);
                                    	att.startActivitySet(as);
                                    	att.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            //adapt all misc activities from old issue
            Iterator iterActivities = getActivitys().iterator();
            while(iterActivities.hasNext()){
            	Activity act = (Activity)iterActivities.next();
            	act.setIssue(newIssue);
            	act.save();
            	newIssue.getActivity(true).add(act); // ?
            }
            
            // Adjust dependencies if its a new issue id
            // (i.e.. moved to new module)
           final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
        }       
       

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "MovedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());

        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "MovedIssueNote"));
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_MOVED,
                                getUniqueId(), newIssue.getUniqueId());

        newIssue.index();
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_MOVED,
                activitySet2, newIssue, user);
        
        return newIssue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Issue copy(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user, 
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // create fresh issue
        newIssue = newModule.getNewIssue(newIssueType);

        if (newIssue != this)
        {
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();

            // Copy over activity sets for the source issue's attribute activities
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();
                ActivitySet newAS = null;
                Attachment newAtt =  null;
                              
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    final Activity a = (Activity)j.next();

                    // Only copy transactions that are records of previous move/copies
                    // Or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // Will be saved when attachments and dependencies are copied
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                        || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // iterate over and copy transaction's activities
                       
                        if(newAS == null){
                        	
                        	 // If old activity set has an attachment, make a copy for new issue
                            if (as.getAttachmentId() != null)
                            {
                                newAtt = as.getAttachment().copy();
                                newAtt.save();
                            }
                        	
            				//init and store new activity set/transaction
                            newAS = new ActivitySet();
                            newAS.setTypeId(as.getTypeId());
                            if (newAtt != null)
                            {
                                newAS.setAttachmentId(newAtt.getAttachmentId());
                            }
                            newAS.setCreatedBy(as.getCreatedBy());
                            newAS.setCreatedDate(as.getCreatedDate());
                            newAS.save();
                        }
                        
                        final Activity newA = a.copy(newIssue, newAS);
                        
                        newIssue.getActivity(true).add(newA);
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                        final AttributeValue newAttVal = att.copy();
                                        newAttVal.setIssueId(newIssue.getIssueId());                                        
                                        newAttVal.setActivity(newA);
                                        newAttVal.startActivitySet(newAS);
                                        newAttVal.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            // add dependencies newly
            final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
            // copy attachments: comments/files etc. and add them, too
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                final Attachment newA = oldA.copy();
                newA.setIssueId(newIssue.getIssueId());
                newA.save();
                final Activity oldAct = oldA.getActivity();
                if (oldAct != null)
                {
                    final ActivitySet activitySet = newIssue.attachActivitySet(null, user);
                    ActivityManager.createTextActivity(newIssue, activitySet,
                        ActivityType.getActivityType(oldA.getActivity().getActivityType()), newA);
                }
                if (Attachment.FILE__PK.equals(newA.getTypeId()))
                {
                    try
                    {
                        oldA.copyFileTo(newA.getFullPath());
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }
        }

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CopiedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());


        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "CopiedIssueNote"));
        
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        // NOTE: There is no distinction bewteen copy and move actions in ActivitySetTypePeer.
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_COPIED,
                                getUniqueId(), newIssue.getUniqueId());
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_COPIED,
                activitySet2, newIssue, user);
        
        newIssue.index();
        
        return newIssue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void addVote(ScarabUser user)
        throws ScarabException, Exception
    {
        // check to see if the user has voted for this issue
        int previousVotes = 0;
        IssueVote issueVote = null;
        Criteria crit = new Criteria()
            .add(IssueVotePeer.ISSUE_ID, getIssueId())
            .add(IssueVotePeer.USER_ID, user.getUserId());
        List votes = IssueVotePeer.doSelect(crit);
        if (votes != null && votes.size() != 0) 
        {
            issueVote = (IssueVote)votes.get(0);
            previousVotes = issueVote.getVotes();
        }
        else 
        {
            issueVote = new IssueVote();
            issueVote.setIssueId(getIssueId());
            issueVote.setUserId(user.getUserId());
        }

        // check if the module accepts multiple votes
        if (!getModule().allowsMultipleVoting() && previousVotes > 0)
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleVoteForUnallowed,
                                      user.getUserName(), 
                                      getUniqueId());
        }
        
        // save the user's vote
        issueVote.setVotes(previousVotes+1);
        issueVote.save();

        // update the total votes for the issue
        crit = new Criteria()
            .add(AttributeValuePeer.ATTRIBUTE_ID, 
                 AttributePeer.TOTAL_VOTES__PK);
        List voteValues = getAttributeValues(crit);
        TotalVotesAttribute voteValue = null;
        if (voteValues.size() == 0) 
        {
            voteValue = new TotalVotesAttribute();
            voteValue.setIssue(this);
            voteValue.setAttributeId(AttributePeer.TOTAL_VOTES__PK);
        }
        else 
        {
            voteValue = (TotalVotesAttribute)voteValues.get(0);
        }
        // Updating attribute values requires a activitySet
        ActivitySet activitySet = attachActivitySet(null, user, null, 
           ActivitySetTypePeer.RETOTAL_ISSUE_VOTE__PK);
        voteValue.startActivitySet(activitySet);
        voteValue.addVote();
        voteValue.save();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void deleteItem(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__DELETE, module)
            || (user.getUserId().equals(getCreatedBy().getUserId()) && isTemplate()))
        {
            setDeleted(true);
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setInitialAttributeValues(ActivitySet activitySet, 
            Attachment attachment, 
            final HashMap newValues, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check new values for workflow
        final String msg = doCheckInitialAttributeValueWorkflow(newValues, user);
        if (msg != null)
        {
            throw new TorqueException(msg); //EXCEPTION
        }
        
        if (activitySet == null)
        {
            // Save activitySet record
            activitySet = ActivitySetManager
                .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
            activitySet.save();
        }
        setActivitySetRelatedByCreatedTransId(activitySet);

        // enter the values into the activitySet
        final LinkedMap avMap = getModuleAttributeValuesMap(); 
        final MapIterator iter = avMap.mapIterator();
        while (iter.hasNext())
        {
            final AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            try
            {
                aval.startActivitySet(activitySet);
            }
            catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
        }        
        this.save();

        // create initial issue creation activity
        ActivityManager.createReportIssueActivity(this, activitySet,  
                Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueCreated"));

        // this needs to be done after the issue is created.
        // check to make sure the attachment has data before submitting it.
        final String attachmentData = attachment.getData();
        if (attachmentData != null &&
            attachmentData.length() > 0)
        {
            attachment = AttachmentManager.getReason(attachment, this, user);
            activitySet.setAttachment(attachment);
        }
        activitySet.save();
        
        // need to clear the cache since this is after the 
        // issue is saved. for some reason, things don't
        // show up properly right away.
        ScarabCache.clear();
        
        index();
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setAttributeValues(ActivitySet activitySet,
                                          final HashMap newAttVals,
                                          final Attachment attachment,
                                          final ScarabUser user)
        throws TorqueException,ScarabException
    {
        if (!isTemplate())
        {
            final String msg = doCheckAttributeValueWorkflow(newAttVals, user);
            if (msg != null)
            {
                throw new ScarabException(L10NKeySet.ErrorExceptionMessage,msg); 
            }
        }
        if (attachment != null)
        {
            attachment.setTextFields(user, this, 
                                     Attachment.MODIFICATION__PK);
            attachment.save();
        }
        activitySet = attachActivitySet(activitySet, user, attachment );
        
        final LinkedMap avMap = getModuleAttributeValuesMap(true); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            final String newAttValValue = newAttVal.getValue();

            if (oldAttVal != null &&
            		(newAttValValue != null && !newAttValValue.equals(oldAttVal.getValue())
            		 || newAttValValue == null)
            		 )
            {
                if (newAttValValue != null && newAttValValue.length() > 0)
                {
                    oldAttVal.setProperties(newAttVal);
                }
                else
                {
                    oldAttVal.setDeleted(true);
                }
                oldAttVal.startActivitySet(activitySet);
                oldAttVal.save();
            }
        }
        index();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public List<Activity> getActivityList() throws ScarabException
    {
        List<Activity> result = null;
/* FIXME: caching is disabled here because new Activities can be
          added to this activityset and the addition does not trigger 
          a reset of this cache (JSS).
        Object obj = ScarabCache.get(this, GET_ACTIVITY_LIST); 
        if (obj == null) 
        {
*/
            Criteria crit = new Criteria()
                .add(ActivityPeer.TRANSACTION_ID, getActivitySetId());
            try
            {
                result = ActivityPeer.doSelect(crit);
            }
            catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
//            ScarabCache.put(result, this, GET_ACTIVITY_LIST);
/*
        }
        else 
        {
            result = (List)obj;
        }
*/
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                       final Attribute attribute,
                                                       final IssueType issueType)
        throws TorqueException, ScarabException
    {
        RModuleUserAttribute result = null;
        final Object obj = ScarabCache.get(this, GET_R_MODULE_USERATTRIBUTE, 
                                     module, attribute, issueType); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria(4)
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId())
                .add(RModuleUserAttributePeer.LIST_ID, null);
            if (module == null) 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, 
                         module.getModuleId());
                
            }            
            if (issueType == null) 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                         issueType.getIssueTypeId());                
            }
            
            final List muas = RModuleUserAttributePeer.doSelect(crit);
            if (muas.size() == 1) 
            {
                result = (RModuleUserAttribute)muas.get(0);
            }
            else if (muas.isEmpty())
            {
                result = 
                    getNewRModuleUserAttribute(attribute, module, issueType);
            }
            else 
            {
                throw new ScarabException(L10NKeySet.ExceptionMultipleJDMs);
            }
            ScarabCache.put(result, this, GET_R_MODULE_USERATTRIBUTE, 
                            module, attribute, issueType);
        }
        else 
        {
            result = (RModuleUserAttribute)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public String setReportingIssue(Issue issue)
        throws ScarabException
    {
        String key = null;
        if (issue == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNullIssueForbidden);
        }
        else 
        {
            key = String.valueOf(issueCount++);
            setReportingIssue(key, issue);
        }
        return key;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public String setCurrentReport(ReportBridge report)
        throws ScarabException
    {
        String key = null;
        if (report == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNullReportForbidden);
        }
        else 
        {
            key = String.valueOf(reportCount++);
            setCurrentReport(key, report);
        }
        return key;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void setHomePage(final String homePage)
        throws TorqueException, ScarabException
    {
        if ("ModuleNotReady.vm".equals(homePage)) 
        {
            throw new ScarabException(L10NKeySet.ExceptionForbiddenHomeModuleNotReady);
        }
        final UserPreference up = UserPreferenceManager.getInstance(getUserId());
        up.setHomePage(homePage);
        up.save();
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public String getRelativePath()
        throws TorqueException,ScarabException
    {
        if (isNew()) 
        {
            throw new ScarabException(L10NKeySet.ExceptionPathNotSet);
        }        
        String path = null;
        String filename = getFileName();
        if (filename != null) 
        {
            // moduleId/(issue_IdCount/1000)/issueID_attID_filename
            StringBuffer sb = new StringBuffer(30 + filename.length());
            final Issue issue = getIssue();
            sb.append("mod").append(issue.getModule().getQueryKey())
                .append(File.separator)
                .append(issue.getIdCount() / 1000)
                .append(File.separator)
                .append(issue.getUniqueId()).append('_')
                .append(getQueryKey()).append('_')
                .append(filename);
            path = sb.toString();
        }
        return path;
    }
            
// in java/org/tigris/scarab/om/ReportPeer.java
public static Report retrieveByName(final String name)
        throws TorqueException, ScarabException
    {
        Report report = null;
        final Criteria crit = new Criteria()
            .add(NAME, name)
            .add(DELETED, false);
        final List reports = doSelect(crit);
        if (reports.size() == 1) 
        {
            report = (Report)reports.get(0);
        }
        else if (reports.size() > 1) 
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleReports,
                                      name);
        }
        
        return report;
    }
            
// in java/org/tigris/scarab/om/AttributeType.java
public static AttributeType getInstance(final String attributeTypeName) 
        throws TorqueException, ScarabException
    {
        AttributeType result = null;
        final Object obj = ScarabCache.get(ATTRIBUTETYPE, GET_INSTANCE, 
                                     attributeTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(AttributeTypePeer.ATTRIBUTE_TYPE_NAME, attributeTypeName);
            final List attributeTypes = AttributeTypePeer.doSelect(crit);
            if(attributeTypes.size() > 1)
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateAttributeTypeName,
                                          attributeTypeName);
            }
            result = (AttributeType)attributeTypes.get(0);
            ScarabCache.put(result, ATTRIBUTETYPE, GET_INSTANCE, 
                            attributeTypeName);
        }
        else 
        {
            result = (AttributeType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Depend.java
public void setObserverUniqueId(String uniqueId)
         throws TorqueException, ScarabException
    {
        if (getDefaultModule() == null)
        {
            throw new ScarabException( L10NKeySet.ExceptionDependInternalWorkflow,
                                       "setDefaultModule()",
                                       "setObserverUniqueId()");
        }
        Issue childIssue = IssueManager.getIssueById(uniqueId.trim());
        if (childIssue == null)
        {
           String code = getDefaultModule().getCode();
           uniqueId = code + uniqueId;
           childIssue = IssueManager.getIssueById(uniqueId);
        }
        super.setObserverId(childIssue.getIssueId());
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped template, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        boolean success = true;
        final Issue issue = IssueManager.getInstance(getIssueId());

        // If it's a module template, user must have Item | Approve 
        //   permission, or its Approved field gets set to false
        if (getScopeId().equals(Scope.PERSONAL__PK)
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        } 
        else
        {
            setApproved(false);
            issue.save();

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");
                
                ScarabUser[] toUsers = module.getUsers(ScarabSecurity.MODULE__EDIT);
                // if the module doesn't have any users, then we need to add at 
                // least ourselves...
                if (toUsers.length == 0)
                {
                    toUsers = new ScarabUser[1];
                    toUsers[0] = user;
                }

                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewTemplateRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx, 
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null, template);
                }
                catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            }
        }
        save();
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getIssue().getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void delete(final ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        final IssueType issueType = getIssueType();

        if (user.hasPermission(ScarabSecurity.MODULE__CONFIGURE, module))
        {
            // Delete both active and inactive attribute groups first
            final List attGroups = issueType.getAttributeGroups(module, false);
            for (int j=0; j<attGroups.size(); j++)
            {
                // delete attribute-attribute group map
                final AttributeGroup attGroup = 
                              (AttributeGroup)attGroups.get(j);
                attGroup.delete();
            }

            // Delete mappings with user attributes
            List rmas = module.getRModuleAttributes(issueType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
            // Delete mappings with user attributes for template type
            final IssueType templateType = issueType.getTemplateIssueType();
            rmas = module.getRModuleAttributes(templateType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
 
            // delete workflows
            WorkflowFactory.getInstance().resetAllWorkflowsForIssueType(module, 
                                                                        issueType);
            // delete templates
            Criteria c = new Criteria()
                .add(IssuePeer.TYPE_ID, templateType.getIssueTypeId());
            final List result = IssuePeer.doSelect(c);
            final List issueIdList = new ArrayList(result.size());
            for (int i=0; i < result.size(); i++) 
            {
                final Issue issue = (Issue)result.get(i);
                issueIdList.add(issue.getIssueId());
            }
            IssuePeer.doDelete(c);
            if (!issueIdList.isEmpty())
            {
                c = new Criteria()
                    .addIn(IssueTemplateInfoPeer.ISSUE_ID, issueIdList);
                IssueTemplateInfoPeer.doDelete(c);
            }
            
            // mit list items
            c = new Criteria()
                .add(MITListItemPeer.MODULE_ID, module.getModuleId())
                .add(MITListItemPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
            final List listItems = MITListItemPeer.doSelect(c);
            final List listIds = new ArrayList(listItems.size());

            for (int i=0; i < listItems.size(); i++) 
            {
                final MITList list = ((MITListItem)listItems.get(i)).getMITList();
                final Long listId = list.getListId();
                if (list.isSingleModuleIssueType() && !listIds.contains(listId))
                {
                    listIds.add(listId);
                }
            }
            MITListItemPeer.doDelete(c);

            if (!listIds.isEmpty())
            {
                // delete single module-issuetype mit lists
                c = new Criteria()
                    .addIn(MITListPeer.LIST_ID, listIds);
                MITListPeer.doDelete(c);

                // delete queries
                c = new Criteria()
                    .addIn(QueryPeer.LIST_ID, listIds);
                QueryPeer.doDelete(c);
            }

            c = new Criteria()
                .add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .add(RModuleIssueTypePeer.ISSUE_TYPE_ID, getIssueTypeId());
            RModuleIssueTypePeer.doDelete(c);
            RModuleIssueTypeManager.removeFromCache(this);
            final List rmits = module.getRModuleIssueTypes();
            rmits.remove(this);
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void delete()
         throws TorqueException, ScarabException
    {                
        int dupeSequence = 0;
        final Integer issueTypeId = getIssueTypeId();
        final IssueType issueType = IssueTypeManager
            .getInstance(SimpleKey.keyFor(issueTypeId), false);
        List attrGroups = null;

        if (isGlobal())
        {
            attrGroups = issueType.getAttributeGroups(null, false);
            dupeSequence =  issueType.getDedupeSequence();
            // Delete issuetype-attribute mapping
            final Criteria crit  = new Criteria()
                .addJoin(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                         RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                .add(RAttributeAttributeGroupPeer.GROUP_ID,
                     getAttributeGroupId())
                .add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, issueTypeId);
            final List results = RIssueTypeAttributePeer.doSelect(crit);
            for (Iterator i = results.iterator(); i.hasNext();)
            {
                ((RIssueTypeAttribute)i.next()).delete();
            }
        }
        else
        {
            if (issueType.getLocked())
            { 
                
                throw new ScarabException(L10NKeySet.ExceptionGroupDeleteForbidden,
                          this.getName(),
                          issueType.getName());
            }            
            else
            {
                final Module module = getModule();
                attrGroups = getIssueType().getAttributeGroups(module, false);
                dupeSequence =  module.getDedupeSequence(issueType);
                // Delete module-attribute mapping
                final Criteria crit  = new Criteria()
                    .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                             RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                    .add(RAttributeAttributeGroupPeer.GROUP_ID,
                             getAttributeGroupId())
                    .add(RModuleAttributePeer.MODULE_ID,
                         getModuleId());
                final Criteria.Criterion critIssueType = crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                getIssueTypeId(), Criteria.EQUAL);
                critIssueType.or(crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                issueType.getTemplateId(), Criteria.EQUAL));
                crit.and(critIssueType);
                final List results = RModuleAttributePeer.doSelect(crit);
                for (int i=0; i<results.size(); i++)
                {
                    final RModuleAttribute rma = (RModuleAttribute)results.get(i);
                    rma.delete();
                }
            }
        }

        // Delete attribute - attribute group mapping
        Criteria crit2 = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, getAttributeGroupId());
        RAttributeAttributeGroupPeer.doDelete(crit2);


        // Delete the attribute group
        final int order = getOrder();
        crit2 = new Criteria()
            .add(AttributeGroupPeer.ATTRIBUTE_GROUP_ID, getAttributeGroupId());
        AttributeGroupPeer.doDelete(crit2);
        IssueTypeManager.getManager().refreshedObject(this);
            
        // Adjust the orders for the other attribute groups
        for (int i=0; i<attrGroups.size(); i++)
        {
            final AttributeGroup tempGroup = (AttributeGroup)attrGroups.get(i);
            int tempOrder = tempGroup.getOrder();
            if (tempGroup.getOrder() > order)
            {
                if (tempOrder == dupeSequence + 1 && tempOrder == 3)
                {
                    tempGroup.setOrder(tempOrder - 2);
                }
                else
                {
                    tempGroup.setOrder(tempOrder - 1);
                }
                tempGroup.save();
            }
        } 
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void deleteAttribute(final Attribute attribute, 
            final ScarabUser user,
            final Module module)
         throws TorqueException, ScarabException
    {                
        String permission = null;
        if (isGlobal())
        {
            permission = (ScarabSecurity.DOMAIN__EDIT);
        }
        else
        {
            permission = (ScarabSecurity.MODULE__CONFIGURE);
        }
        if (user.hasPermission(permission, module))
        {
            final IssueType issueType = getIssueType();
            final IssueType template = IssueTypeManager.getInstance
                                 (issueType.getTemplateId());
            boolean success = true;

            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
            if (isGlobal())
            {
                // This is a global attribute group
                // Remove attribute - issue type mapping
                final List rias = issueType.getRIssueTypeAttributes
                                     (false, AttributePeer.NON_USER);
                if (ria != null) 
                {
                    ria.delete();                    
                }
                if (rias != null) 
                {
                    rias.remove(ria);        
                }
            }
            else
            {
                // Check if attribute is locked
                if (ria != null && ria.getLocked())
                {
                    success = false;
                    throw new TorqueException(attribute.getName() + "is locked"); //EXCEPTION
                }
                else
                {
                    // Remove attribute - module mapping
                    final List rmas = module.getRModuleAttributes(issueType, false,
                                                            AttributePeer.NON_USER);    
                    final RModuleAttribute rma = module
                        .getRModuleAttribute(attribute, issueType);
                    if(rma != null)rma.delete();
                    WorkflowFactory.getInstance().deleteWorkflowsForAttribute
                                                  (attribute, module, issueType);
                    if(rma != null)rmas.remove(rma);

                    // Remove attribute - module mapping from template type
                    final RModuleAttribute rma2 = module
                                   .getRModuleAttribute(attribute, template);
                    if(rma2 != null)
                    {
                        rma2.delete();
                        rmas.remove(rma2);
                    }
                }
            }

            if (success)
            {
                // Remove attribute - group mapping
                final RAttributeAttributeGroup raag = 
                    getRAttributeAttributeGroup(attribute);
                raag.delete();

                if (attribute.isOptionAttribute())
                {
                    if (isGlobal())
                    { 
                        // global attributeGroup; remove issuetype-option maps
                        final List rios = issueType.getRIssueTypeOptions(attribute);
                        if (rios != null)
                        {
                            for (int i = 0; i<rios.size();i++)
                            {
                                ((RIssueTypeOption) rios.get(i))
                                    .delete(user, module);
                            }
                        }
                    }
                    else
                    {
                        // Remove module-option mapping
                        final List rmos = module.getRModuleOptions(attribute, issueType);
                        if (rmos != null)
                        {
                            rmos.addAll(module.getRModuleOptions(attribute, template));
                            for (int j = 0; j<rmos.size();j++)
                            {
                                final RModuleOption rmo = (RModuleOption)rmos.get(j);
                                 // rmo's may be inherited by the parent module.
                                 // don't delete unless they are directly associated
                                 // with this module.  Will know by the first one.
                                 if (rmo.getModuleId().equals(module.getModuleId())) 
                                 {
                                     rmo.delete();
                                 }
                                 else 
                                 {
                                     break;
                                 } 
                             }
                         }
                     }
                 }
             }
         }
         else
         {
             throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
         }            
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
            
// in java/org/tigris/scarab/om/AttachmentType.java
public static AttachmentType getInstance(String attachmentTypeName)
        throws TorqueException,ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(BaseAttachmentTypePeer.ATTACHMENT_TYPE_NAME, attachmentTypeName);
        List attachmentTypes = AttachmentTypePeer.doSelect(crit);
        if(attachmentTypes.size() > 1)
        {
            throw new ScarabException(L10NKeySet.ExceptionAttachmentDuplicateTypename);
        }
        return (AttachmentType)attachmentTypes.get(0);
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public List getTransitions(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        Module module = user.getCurrentModule();
        List result = null;
        List availableOptions = getAvailableOptions(issueType, attribute, module);

        Iterator optionsIter = availableOptions.iterator();
        while(optionsIter.hasNext())
        {
            RModuleOption rmoduleOption = (RModuleOption)optionsIter.next();
            AttributeOption fromOption;
            try
            {
                fromOption = rmoduleOption.getAttributeOption();
            }
            catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            List list = getTransitionsFrom(user,issueType,attribute,fromOption);
            if(list != null)
            {
                if(result == null)
                {
                    result = list;
                }
                else
                {
                    result.addAll(list);
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public TransitionNode getTransitionTree(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        Module module = user.getCurrentModule();
        TransitionNode result = null;
        List availableOptions = getAvailableOptions(issueType, attribute, module,false);
        List visitedTransitions = null;
        Iterator optionsIter = availableOptions.iterator();
        while(optionsIter.hasNext())
        {
            RModuleOption rmoduleOption = (RModuleOption)optionsIter.next();
            AttributeOption fromOption;
            try
            {
                fromOption = rmoduleOption.getAttributeOption();
            }
            catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            List list = getTransitionsFrom(user,issueType,attribute,fromOption,false);
            if(list != null)
            {
                if(result == null)
                {
                    result = new TransitionNode(fromOption);
                }
                for(int index=0; index < list.size(); index++)
                {
                    Transition t = (Transition)list.get(index);
                    if(visitedTransitions == null)
                    {
                        visitedTransitions = new ArrayList();
                    }
                    if(visitedTransitions.contains(t))
                    {
                        continue;
                    }
                    visitedTransitions.add(t);
                    TransitionNode child = result.addNode(t);
                    getTransitionTree(user, issueType, attribute, t.getTo(), child, visitedTransitions);
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private List getAvailableOptions(IssueType issueType, Attribute attribute, Module module, boolean activeOnly) throws ScarabException
    {
        List availableOptions;
        try 
        {
            availableOptions = module.getOptionTree(attribute,issueType,activeOnly);
        } catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
        return availableOptions;
    }
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
public static Workflow getInstance() throws ScarabException
    {
        Workflow wf = null;
        String className = null;
        try
        {
            if (getForceUseDefault())
            {
                wf = (Workflow) DefaultWorkflow.class.newInstance();
            }
            else
            {
                List classNames = Turbine.getConfiguration()
                    .getList("scarab.workflow.classname");
                if (classNames.size() > 0)
                {
                    className = (String) classNames.get(0);
                }
    
                Class wfClass = (className != null ? Class.forName(className) :
                                 DefaultWorkflow.class);
                wf = (Workflow) wfClass.newInstance();
            }
        }
        catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
        catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
        catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
        return wf;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
void doHandleDependencies()
        throws ScarabException, TorqueException
    {
        LOG.debug("Number of dependencies found: " + allDependencies.size());
        for (Iterator itr = allDependencies.iterator(); itr.hasNext();)
        {
            final Object[] data = (Object[])itr.next();
            final ActivitySet activitySetOM = (ActivitySet) data[0];
            final XmlActivity activity = (XmlActivity) data[1];
            

            final Dependency dependency = activity.getDependency();
            final String child = (String)issueXMLMap.get(dependency.getChild());
            final String parent = (String)issueXMLMap.get(dependency.getParent());
            if (parent == null || child == null)
            {
                if(null != parent || null != child)
                {
                    // add a comment into the issue that informs of the dependency
                    final Issue issueOM = IssueManager.getIssueById(null == parent ? child : parent);
                    final Attachment attachmentOM = new Attachment();
                    attachmentOM.setName("comment");
                    attachmentOM.setTypeId(Attachment.COMMENT__PK);
                    attachmentOM.setMimeType("text/plain");
                    // TODO i18n this
                    final String text = "Dependency \"" 
                            + parent + " (originally " + dependency.getParent() + ") " + dependency.getType() + ' ' 
                            + child + " (originally " + dependency.getParent()
                        + ") \" was not imported due to " 
                        + (null == parent ? dependency.getParent() : dependency.getChild()) + " not being resolved";
                    attachmentOM.setData(text);                    
                    issueOM.addComment(attachmentOM, ScarabUserManager.getInstance("Administrator"));
                }
                
                LOG.debug("Could not find issues: parent: " + parent + " child: " + child);
                LOG.debug("----------------------------------------------------");
                continue;
            }
            LOG.debug("doHandleDependencies: " + dependency);
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                LOG.error("[TODO] update-same-db import type not yet implemented");
                // trick here is that dependencies don't have ids or unique keys to find the 
                //  correct existing instance against.
            }
            else
            {
                try
                {
                    final String type = dependency.getType();
                    final Depend newDependOM = DependManager.getInstance();
                    final Issue parentIssueOM = IssueManager.getIssueById(parent);
                    final Issue childIssueOM = IssueManager.getIssueById(child);
                    newDependOM.setDefaultModule(parentIssueOM.getModule());
                    newDependOM.setObservedId(parentIssueOM.getIssueId());
                    newDependOM.setObserverId(childIssueOM.getIssueId());
                    newDependOM.setDependType(type);
                    LOG.debug("Dep: " + type + " Parent: " + parent + " Child: " + child);
                    LOG.debug("XML Activity id: " + activity.getId());
                    if (activity.isAddDependency())
                    {
                        parentIssueOM
                          .doAddDependency(activitySetOM, newDependOM, childIssueOM, null);
                        LOG.debug("Added Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isDeleteDependency())
                    {
                        parentIssueOM
                          .doDeleteDependency(activitySetOM, newDependOM, null);
                        LOG.debug("Deleted Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isUpdateDependency())
                    {
                        final Depend oldDependOM = parentIssueOM.getDependency(childIssueOM);
                        if (oldDependOM == null)
                        {
                            throw new IllegalArgumentException ("Whoops! Could not find the original dependency!"); //EXCEPTION
                        }
                        // we definitely know we are doing an update here.
                        newDependOM.setDeleted(false);
                        parentIssueOM
                          .doChangeDependencyType(activitySetOM, oldDependOM, newDependOM, null);
                        LOG.debug("Updated Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("Old Type: " + oldDependOM.getDependType().getName() + " New type: " + newDependOM.getDependType().getName());
                        LOG.debug("----------------------------------------------------");
                    }
                }
                catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }                
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
public void addIssue(final XmlIssue issue)
        throws ScarabException
    {
        LOG.debug("Module.addIssue(): " + issue.getId());
        try
        {
            if (inValidationMode)
            {
                importErrors.setParseContext((issue.hasModuleCode()
                    ?"":module.getCode()) + issue.getId());
                doIssueValidateEvent(getModule(), issue);
            }
            else
            {
                doIssueEvent(getModule(), issue);
            }
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
        catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
        finally
        {
            importErrors.setParseContext(null);
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueEvent(final XmlModule module, final XmlIssue issue)
        throws TorqueException,ScarabException,ParseException
    {
/////////////////////////////////////////////////////////////////////////////////  
        // Get me an issue
        Issue issueOM = null;
        final String issueID = (issue.hasModuleCode() ? "" : module.getCode()) + issue.getId();
        if (getImportTypeCode() == CREATE_SAME_DB || getImportTypeCode() == CREATE_DIFFERENT_DB)
        {
            // Check if the new issue nominates an ID and if the database does
            // not already contain an issue with that ID
            if (issue.getId() != null && IssueManager.getIssueById(issueID) == null)
            {
                // Create the new issue with the nominated ID
                issueOM = createNewIssue(module, issue, issue.getId());
            }
            else
            {
                // Crate the new issue with an automatically allocated ID
                issueOM = createNewIssue(module, issue, null);
            }
        }
        else if (getImportTypeCode() == UPDATE_SAME_DB) // nice to specify just for searching/refactoring
        {
            issueOM = IssueManager.getIssueById(issueID);
            
            if (issueOM == null)
            {
                issueOM = createNewIssue(module, issue, null);
            }
            else
            {
                LOG.debug("Found Issue in db: " + issueOM.getUniqueId());
            }
        }

/////////////////////////////////////////////////////////////////////////////////  

        // Loop over the XML activitySets
        final List activitySets = issue.getActivitySets();
        LOG.debug("-----------------------------------");
        LOG.debug("Number of ActivitySets in Issue: " + activitySets.size());
        for (Iterator itr = activitySets.iterator(); itr.hasNext();)
        {
            final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
            LOG.debug("Processing ActivitySet: " + activitySet.getId());

/////////////////////////////////////////////////////////////////////////////////  
            // Deal with the attachment for the activitySet
            final XmlAttachment activitySetAttachment = activitySet.getAttachment();
            Attachment activitySetAttachmentOM = null;
            if (activitySetAttachment != null)
            {
                if (getImportTypeCode() == UPDATE_SAME_DB)
                {
                    try
                    {
                        activitySetAttachmentOM = AttachmentManager
                            .getInstance(activitySetAttachment.getId());
                        LOG.debug("Found existing ActivitySet Attachment");
                    }
                    catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
                }
                else
                {
                    activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    LOG.debug("Created ActivitySet Attachment object");
                }
            }
            else
            {
                LOG.debug("OK- No Attachment in this ActivitySet");
            }

/////////////////////////////////////////////////////////////////////////////////  
            // Attempt to get the activitySet OM
            boolean alreadyCreated = false;
            ActivitySet activitySetOM = null;
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                try
                {
                    activitySetOM = ActivitySetManager.getInstance(activitySet.getId());
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in db: " + activitySetOM.getActivitySetId());
                }
                catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            }
            else
            {
                // first try to get the ActivitySet from the internal map
                if (activitySetIdMap.containsKey(activitySet.getId()))
                {
                    activitySetOM = ActivitySetManager.getInstance(
                        (String)activitySetIdMap.get(activitySet.getId()));
                    alreadyCreated = true;
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in map: " + activitySetOM.getActivitySetId());
                }
                else // it hasn't been encountered previously
                {
                    activitySetOM = ActivitySetManager.getInstance();
                    LOG.debug("Created new ActivitySet");
                }
            }

            final ScarabUser activitySetCreatedByOM = findUser(activitySet.getCreatedBy());
            
            if (LOG.isDebugEnabled())
            {
                LOG.debug("ActivitySet: " + activitySet.getId() + "; of type: " + activitySet.getType() + "; by: " + activitySet.getCreatedBy());
                LOG.debug("   alreadyCreated: " + alreadyCreated);
            }
            
            if (!alreadyCreated)
            {
                // Populate the ActivitySet
                // Get the ActivitySet type/createdby values (we know these are valid)
                final ActivitySetType ttOM = ActivitySetTypeManager.getInstance(activitySet.getType());
                activitySetOM.setActivitySetType(ttOM);
                if( activitySetCreatedByOM != null ){
                    activitySetOM.setCreatedBy(activitySetCreatedByOM.getUserId());
                }
                else
                {
                	// Anonymous user. better than nothing.
                	try {
						activitySetOM.setCreatedBy(ScarabUserManager.getAnonymousUser().getUserId());
					} catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                }
                activitySetOM.setCreatedDate(activitySet.getCreatedDate().getDate());
                if (activitySetAttachmentOM != null)
                {
                    activitySetAttachmentOM.save();
                    activitySetOM.setAttachment(activitySetAttachmentOM);
                }
                activitySetOM.save();
                if( activitySet.getId() != null){
                    // if id is valid, save for later re-use.
                    activitySetIdMap.put(activitySet.getId(), 
                                         activitySetOM.getPrimaryKey().toString());
                }
            }

            // Determine if this ActivitySet should be marked as the 
            // creation event
            final ActivitySet creationSet = issueOM.getActivitySetRelatedByCreatedTransId();
            if (ActivitySetTypePeer.CREATE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) 
               ||
               (ActivitySetTypePeer.MOVE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) && 
                        (creationSet == null || activitySetOM.getCreatedDate()
                         .before(creationSet.getCreatedDate()))) ) 
            {
                issueOM.setActivitySetRelatedByCreatedTransId(activitySetOM);
                issueOM.save();
            }

/////////////////////////////////////////////////////////////////////////////////  
// Deal with changing user attributes. this code needs to be in this *strange*
// location because we look at the entire activityset in order to determine
// that this is a change user activity set. of course in the future, it would
// be really nice to create an activityset/activiy type that more accurately 
// reflects what type of change this is. so that it is easier to case for. for
// now, we just look at some fingerprints to determine this information. -JSS

            if (activitySet.isChangeUserAttribute())
            {
                final List activities = activitySet.getActivities();
                final XmlActivity activityA = (XmlActivity)activities.get(0);
                final XmlActivity activityB = (XmlActivity)activities.get(1);
                
                final ScarabUser assigneeOM = findUser(activityA.getOldUser());
                final ScarabUser assignerOM = findUser(activityB.getNewUser());

                final Attribute oldAttributeOM = Attribute.getInstance(activityA.getAttribute());

                final AttributeValue oldAttValOM = issueOM.getUserAttributeValue(assigneeOM, oldAttributeOM);
                if (oldAttValOM == null)
                {
                    LOG.error("User '" + assigneeOM.getName() + "' was not previously '" + oldAttributeOM.getName() + "' to the issue!");
                }

                // Get the Attribute associated with the new Activity
                final Attribute newAttributeOM = Attribute.getInstance(activityB.getAttribute());

                issueOM.changeUserAttributeValue(activitySetOM,
                            assigneeOM, 
                            assignerOM, 
                            oldAttValOM,
                            newAttributeOM, null);
                LOG.debug("-------------Updated User AttributeValue------------");
                continue;
            }

/////////////////////////////////////////////////////////////////////////////////  

            // Deal with the activities in the activitySet
            final List activities = activitySet.getActivities();
            LOG.debug("Number of Activities in ActivitySet: " + activities.size());

            final LinkedMap avMap = issueOM.getModuleAttributeValuesMap();
            LOG.debug("Total Module Attribute Values: " + avMap.size());
            for (Iterator itrb = activities.iterator(); itrb.hasNext();)
            {
                final XmlActivity activity = (XmlActivity) itrb.next();
                LOG.debug("Looking at activity id: " + activity.getId());

                // Get the Attribute associated with the Activity
                final Attribute attributeOM = Attribute.getInstance(activity.getAttribute());

                // deal with the activity attachment (if there is one)
                final XmlAttachment activityAttachment = activity.getAttachment();
                Attachment activityAttachmentOM = null;
                if (activityAttachment != null)
                {
                    // look for an existing attachment in the activity
                    // the case is when we have a URL and we create it
                    // and then delete it, the attachment id is still the
                    // same so there is no reason to re-create the attachment
                    // again.
                    final String previousXmlId = activityAttachment.getId();
                    final String previousId = (String)attachmentIdMap.get(previousXmlId);
                    if (previousId == null) 
                    {
                        activityAttachmentOM = createAttachment(issueOM, activityAttachment);
                        activityAttachmentOM.save();
                        attachmentIdMap.put(previousXmlId, activityAttachmentOM.getPrimaryKey().toString());
                        
                        // Special case. After the Attachment object has been 
                        // saved, if the ReconcilePath == true, then assume 
                        // that the fileName is an absolute path to a file and
                        // copy it to the right directory
                        // structure under Scarab's path.
                        if (allowFileAttachments && activityAttachment.getReconcilePath())
                        {
                            try
                            {
                                activityAttachmentOM
                                    .copyFileFromTo(activityAttachment.getFilename(), 
                                                    activityAttachmentOM.getFullPath());
                            } 
                            catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            } 
                            catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                        }
                        LOG.debug("Created Activity Attachment object");
                    }
                    else 
                    {
                        activityAttachmentOM = AttachmentManager
                            .getInstance(previousId);
                        LOG.debug("Found existing Activity Attachment");
                    }
                }
                else
                {
                    LOG.debug("OK- No Attachment in this Activity");
                }

                // deal with null attributes (need to do this before we create the 
                // activity right below because this will create its own activity).
                if (attributeOM.equals(nullAttribute))
                {
                    // add any dependency activities to a list for later processing
                    if (isDependencyActivity(activity))
                    {
                        if (!isDuplicateDependency(activity))
                        {
                            final Object[] obj = {activitySetOM, activity, activityAttachmentOM};
                            allDependencies.add(obj);
                            dependActivitySetId.add(activity.getDependency());
                            LOG.debug("-------------Stored Dependency # " 
                                    + allDependencies.size() + '[' + activity.getDependency() + ']');
                            continue;
                        }
                    }
                    else
                    {
                        // create the activity record.
                        ActivityManager.createTextActivity(issueOM, nullAttribute, activitySetOM, 
                                    ActivityType.getActivityType(activity.getActivityType()), activity.getDescription(), activityAttachmentOM, 
                                    activity.getOldValue(), activity.getNewValue());
        
                        LOG.debug("-------------Saved Null Attribute-------------");
                        continue;
                    }
                }

                // create the activityOM
                createActivity(activity, module, 
                                            issueOM, attributeOM, activitySetOM);

                // check to see if this is a new activity or an update activity
                AttributeValue avalOM = null;
                for (Iterator moduleAttributeValueItr = avMap.mapIterator(); 
                     moduleAttributeValueItr.hasNext() && avalOM == null;)
                {
                    final AttributeValue testAvalOM = (AttributeValue)
                        avMap.get(moduleAttributeValueItr.next());
                    final Attribute avalAttributeOM = testAvalOM.getAttribute();

                    LOG.debug("Checking Attribute match: " + avalAttributeOM.getName() + 
                              " against: " + attributeOM.getName());
                    if (avalAttributeOM.equals(attributeOM))
                    {
                        avalOM = testAvalOM;
                    }
                }

                if (avalOM != null) 
                {
                    final Attribute avalAttributeOM = avalOM.getAttribute();
                    LOG.debug("Attributes match!");
                    AttributeValue avalOM2 = null;
                    if (!activity.isNewActivity())
                    {
                        LOG.debug("Activity is not new.");
                        avalOM2 = AttributeValue.getNewInstance(
                            avalAttributeOM.getAttributeId(), 
                            avalOM.getIssue());
                        avalOM2.setProperties(avalOM);
                    }

                    if (avalAttributeOM.isOptionAttribute())
                    {
                        LOG.debug("We have an Option Attribute: " + 
                                  avalAttributeOM.getName());
                        final AttributeOption newAttributeOptionOM = 
                                AttributeOptionManager.getInstance(
                                         attributeOM, activity.getNewOption(),
                                         issueOM.getModule(),
                                         issueOM.getIssueType());
                        if (activity.isNewActivity())
                        {
                            if (newAttributeOptionOM != null)
                            {
                                avalOM.setOptionId(newAttributeOptionOM.getOptionId());
                                avalOM.startActivitySet(activitySetOM);
                                avalOM.setAttribute(attributeOM);
                                avalOM.save();
                                LOG.debug("-------------Saved Attribute Value-------------");
                            }
                            else
                            {
                                LOG.warn("NewAttributeOptionOM is null for " +
                                         activity.getNewOption());
                            }
                        }
                        else if(newAttributeOptionOM != null)
                        {
                            avalOM2.setOptionId(newAttributeOptionOM.getOptionId());
                            final HashMap map = new HashMap();
                            map.put(avalOM.getAttributeId(), avalOM2);
                            issueOM.setAttributeValues(activitySetOM, map, null, activitySetCreatedByOM);
                            LOG.debug("-------------Saved Option Attribute Change-------------");
                        }
                    }
                    else if (avalAttributeOM.isUserAttribute())
                    {
                        LOG.debug("We have a User Attribute: " 
                                  + avalAttributeOM.getName());
                        if (activity.isNewActivity())
                        {
                            // Don't need to pass in the attachment because
                            // it is already in the activitySetOM.
                            // If we can't get an assignee new-user, then 
                            // use the activity set creator as assignee.
                            ScarabUser assigneeOM = findUser(activity.getNewUser());
                            assigneeOM = (assigneeOM != null)
                                ? assigneeOM: activitySetCreatedByOM;
                            if( assigneeOM != null ){
                                issueOM.assignUser(activitySetOM, 
                                    assigneeOM, null, avalAttributeOM, null);
                            }
                            LOG.debug("-------------Saved User Assign-------------");
                        }
                        else if (activity.isRemoveUserActivity())
                        {
                            // remove a user activity
                            final ScarabUser oldUserOM = findUser(activity.getOldUser());
                            // need to reset the aval because the current one
                            // is marked as new for some reason which causes an
                            // insert and that isn't the right behavior here 
                            // (we want an update)
                            avalOM = null;
                            for (Iterator i = issueOM.getAttributeValues(
                                 avalAttributeOM).iterator(); 
                                 i.hasNext() && avalOM == null;) 
                            {
                                final AttributeValue av = (AttributeValue)i.next();
                                if (oldUserOM.getUserId().equals(av.getUserId())) 
                                {
                                    avalOM = av;
                                }
                            }

                            if (avalOM == null) 
                            {
                                if (LOG.isDebugEnabled()) 
                                {
                                    LOG.debug("Could not find previous AttributeValue assigning " +
                                        (oldUserOM == null ? "NULL" : 
                                        oldUserOM.getUserName()) + 
                                        " to attribute " + 
                                              avalAttributeOM.getName());
                                }                                
                            }
                            else 
                            {
                                // don't need to pass in the attachment because
                                // it is already in the activitySetOM
                                issueOM.deleteUser(activitySetOM, oldUserOM, 
                                    activitySetCreatedByOM, avalOM, null);
                                LOG.debug("-------------Saved User Remove-------------");
                            }
                        }
                    }
                    else if (avalAttributeOM.isTextAttribute() || avalAttributeOM.isIntegerAttribute())
                    {
                        LOG.debug("We have a Text Attribute: " + avalAttributeOM.getName());

                        avalOM.startActivitySet(activitySetOM);
                        avalOM.setAttribute(attributeOM);

                        if (activity.isNewActivity())
                        {
                            avalOM.setValue(activity.getNewValue());
                        }
                        else if (!activity.getNewValue()
                                .equals(avalOM.getValue()))
                        {
                            avalOM2.setValue(activity.getNewValue());
                            avalOM.setProperties(avalOM2);
                        }
                        
                        avalOM.save();
                        LOG.debug("-------------Saved Attribute Value-------------");
                    }
                }
                issueOM.save();
                LOG.debug("-------------Saved Issue-------------");
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Module getModuleForIssue(final XmlModule module, final XmlIssue issue)
        throws TorqueException, ScarabException
    {
        
        if(issue.hasModuleCode() && !issue.getModuleCode().equals(module.getCode()) && !allowGlobalImport){
            throw new ScarabException(
                    new L10NKey("Lacking permission to cross-module import. Contact your administor. <localize me>"));
        }
        
        return issue.hasModuleCode()
                ? ModuleManager.getInstance(module.getDomain(),
                                            null,issue.getModuleCode())
                : ModuleManager.getInstance(module.getDomain(),
                                            module.getName(), module.getCode());
     }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected Collection runImport(final String filePath, 
            final Object input,
            final Module currentModule,
            final ImportType type)
        throws ScarabException
    {
        
        final String msg = "Importing issues from XML '" + filePath + '\'';
        LOG.debug(msg);
        try
        {
            // Disable workflow and set file attachment flag
            WorkflowFactory.setForceUseDefault(true);
            
            final Reader is = getScarabFormattedReader(input,type,currentModule);
            
            final BeanReader reader = createScarabIssuesBeanReader();
            validate(filePath, is, reader, currentModule);

            if (importErrors == null || importErrors.isEmpty())
            {
                // Reget the input stream.
                si = insert(filePath, getScarabFormattedReader(input,type,currentModule), reader);
            }
        }
        catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
        finally
        {
            // Re-enable workflow.
            WorkflowFactory.setForceUseDefault(false);
        }

        return importErrors;
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
public List executeQuery(TextQuery textQuery) 
        throws Exception
    {
        String queryText = textQuery.toString();
        
        Query luceneQuery;
        try
        {
           luceneQuery = new QueryParser("", analyzer).parse(queryText);
        }
        catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }

        List issueIds = new ArrayList();
        IndexSearcher is = new IndexSearcher(indexDir); 
        try
        {
            Hits hits = is.search(luceneQuery);
            
            for(Iterator hi = hits.iterator(); hi.hasNext();)
            {
                Hit h = (Hit)hi.next();
                issueIds.add( Long.valueOf(h.get(ISSUE_ID)));
            }
        }
        finally
        {
            is.close();
        }        
        return issueIds;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addIssueIdRangeCriteria(Criteria crit)
        throws java.lang.Exception
    {
        Issue.FederatedId minFid = null;
        Issue.FederatedId maxFid = null;

        if(minId != null)
        {
            minFid = new Issue.FederatedId(minId);
        }
        if(maxId != null)
        {
            maxFid = new Issue.FederatedId(maxId);
        }
        setDefaults(minFid, maxFid);

        if ( minFid != null
          && maxFid != null
          && (   minFid.getCount() > maxFid.getCount() 
              || !StringUtils.equals(minFid.getPrefix(), maxFid.getPrefix())
              || !StringUtils.equals(minFid.getDomain(), maxFid.getDomain())))
        {
            throw new ScarabException(L10NKeySet.ExceptionIncompatibleIssueIds, minId, maxId);
        }
        else 
        {
            addIssueIdCrit(crit, minFid, Criteria.GREATER_EQUAL );
            addIssueIdCrit(crit, maxFid, Criteria.LESS_EQUAL );
        }        
    }
            
// in java/org/tigris/scarab/util/TurbineInitialization.java
public static void setUp(final String configDir, final String configFile)
        throws ScarabException,MalformedURLException,IOException
    {
        if (configDir == null || configFile == null)
        {
            System.err.println("config.dir System property was not defined");
            throw new ScarabException (new L10NKey("configDir or configFile was null")); // FIXME localise
        }

        // set this so that the proper substitution will happen in the
        // configFile
        System.getProperties().setProperty("configDir", configDir);

        initTurbine(configDir);
        
        final InputStream is = new File(configDir + configFile).toURL()
            .openStream();
        final Properties props = new Properties();
        try
        {
            props.load(is);
            // init Log4J
            PropertyConfigurator.configure(props);
        }
        catch (Exception e)
        {
            System.err.println("Can't read the properties file (" + 
                configDir + configFile + "). ");
        }
    }
            
// in java/org/tigris/scarab/util/Email.java
private static void sendEmailInLocale(EmailContext context, Module module,
                                          Object fromUser, Object replyToUser,
                                          List toAddresses, List ccAddresses,
                                          String template, Locale locale)
        throws Exception
    {
        log.debug("Sending email for locale=" + locale);

        // get reference to l10n tool, so we can alter the locale per email
        ScarabLocalizationTool l10n = new ScarabLocalizationTool();
        context.setLocalizationTool(l10n);
        l10n.init(locale);

        Email te = getEmail(context, module, fromUser, replyToUser, template);

        final String charSet = getCharset(locale);
        te.setCharset(charSet);
        context.put("charSet", new String(charSet));
        
        //te.addHeader("Content-Base: "");

        boolean atLeastOneTo = false;
        for (Iterator iTo = toAddresses.iterator(); iTo.hasNext();)
        {
            InternetAddress a = (InternetAddress) iTo.next();
            log.debug("Adding To: email[" + a.getAddress() + "], name["+a.getPersonal()+"]");
            te.addTo(a.getAddress(), a.getPersonal());
            atLeastOneTo = true;
        }
        for (Iterator iCC = ccAddresses.iterator(); iCC.hasNext();)
        {
            InternetAddress a = (InternetAddress) iCC.next();
            String email = a.getAddress();
            String name = a.getPersonal();

            
            // template email requires a To: user, it does seem possible
            // to send emails with only a CC: user, so not sure if this
            // is a bug to be fixed in TemplateEmail.  Might not be good
            // form anyway.  So if there are no To: users, upgrade CC's.
            if (atLeastOneTo)
            {
                log.debug("Adding CC: email[" + email + "], name["+name+"]");
                te.addCc(email, name);
            }
            else
            {
                log.debug("Adding to: email[" + email + "], name["+name+"]");
                te.addTo(email, name);
                // We've added one To: user and TemplateEmail should be
                // happy. No need to move all CC: into TO:
                atLeastOneTo = true;
            }
        }

        // Email threading -- applicable to issue related notifications
        Issue issue = null;
        String emailReferences = null;
        if(context.containsKey("issue"))
        {
            issue = (Issue) context.get("issue");
            emailReferences = null != issue.getEmailReferences()
                    ? issue.getEmailReferences()
                    : "";
            if(0 != emailReferences.length())
            {
                te.addHeader("References", emailReferences);
            }
        }

        String newEmailReference = null;
        try
        {
            log.debug("Sending email ...");
            newEmailReference = te.send();
            log.debug("... sent " + newEmailReference);
        }
        catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }

        if(null!=emailReferences && null!=newEmailReference)
        {
            // we record, within the varchar(2000) limit,
            // the MessageID of every mail sent if it's related to an issue change 
            // There must be an error in the length calculation, which sometimes causes
            // the issue.save() to throw an illegalLength exception. I tried to take care
            // of this here. [HD]

            if(emailReferences.length()>0) emailReferences += ' ';
            emailReferences += newEmailReference; 

            if(emailReferences.length() > 2000)
            {
                emailReferences = emailReferences.substring(
                        emailReferences.indexOf('<', emailReferences.length() - 2000));
            }
            try
            {
                issue.setEmailReferences(emailReferences);
                issue.save();
            }
            catch(Exception e)
            {
                log.warn("Failed to store EMAIL_REFERENCES for issue ["+issue.getIdCount()+"]");
                log.warn("EMAIL_REFERENCES.length was " + emailReferences.length());
                log.warn("Detailed error message was: " + e.getMessage());
                //Not throwing an exception here, because the email itself could be successfully transmitted
            }
        }
    }
36 
            
// in java/org/tigris/scarab/om/MITList.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
            
// in java/org/tigris/scarab/om/ROptionOption.java
catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/MITListItem.java
catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
            
// in java/org/tigris/scarab/om/Issue.java
catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
            
// in java/org/tigris/scarab/om/ActivitySet.java
catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
catch (ParseException e)
        {
            throw new ScarabException( L10NKeySet.ExceptionParseError, queryText, e);
        }
            
// in java/org/tigris/scarab/util/Email.java
catch(EmailException me)
        {
            log.warn("Could not send Email. Cause ["+me.getMessage()+"]");
            if(me.getCause() != null)
            {
                log.warn("Cause: ["+me.getCause().getMessage());
            }
            Throwable t = me.getCause();
            throw new ScarabException(L10NKeySet.ExceptionEmailFailure,t);
        }
172 
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Object getSessionAttribute(String key) throws ScarabException
    {
        HttpSession session = data.getSession();
        Object value;
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        value = session.getAttribute(key);
        return value;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean hasSessionAttribute(String key) throws ScarabException
    {
        HttpSession session = data.getSession();
        Object value;
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        value = session.getAttribute(key);
        return value != null;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean setSessionAttribute(String key, Object value) throws ScarabException
    {
        HttpSession session = data.getSession();
        if(session == null)
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.NoSessionAvailable);
            throw new ScarabException(msg);
        }
        session.setAttribute(key,value);
        return true;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getTransitions(IssueType issueType,
            Attribute attribute) throws ScarabException
   {
        ScarabUser user = getCurrentUser();
        Workflow workflow = ScarabGlobalTool.getWorkflow();
        List result = workflow.getTransitions(user,issueType,attribute);
        return result;
   }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getTransitionMatrix(IssueType issueType,
            Attribute attribute) throws ScarabException
   {
        ScarabUser user = getCurrentUser();
        Workflow workflow = ScarabGlobalTool.getWorkflow();
        TransitionNode root = workflow.getTransitionTree(user,issueType,attribute);
        List result = root.createRows();
        return result;
   }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public static NotificationRule getNotificationRule(Integer moduleId, Integer userId, String activityCode) throws ScarabException
    {
        NotificationRule result = NotificationRuleManager.getNotificationRule(moduleId, userId, activityCode);
        return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public static Workflow getWorkflow() throws ScarabException
    {
        return WorkflowFactory.getInstance();
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setChainedValue(final AttributeValue  v)
        throws TorqueException, ScarabException
    {
        if (v == null)
        {
            this.chainedValue = null;
        }
        else 
        {        
            if (v.getAttributeId() == null && getAttributeId() != null) 
            {
                v.setAttributeId(getAttributeId());
            }
            else if (v.getAttribute() != null 
                     && !v.getAttribute().equals(getAttribute()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainAttributeValues,
                                          v.getAttributeId(),
                                          getAttributeId());
            }
            
            if (v.getIssueId() == null && getIssueId() != null) 
            {
                v.setIssueId(getIssueId());
            }
            else if (v.getIssue() != null 
                      && !v.getIssue().equals(getIssue()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainIssues,
                                          v.getIssueId(),
                                          getIssueId());
            }

            if (this.chainedValue == null) 
            {
                this.chainedValue = v;
            }
            else 
            {
                chainedValue.setChainedValue(v);
            }
            
            if (activitySet != null) 
            {
                v.startActivitySet(activitySet);
            }        
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void startActivitySet(ActivitySet activitySet)
        throws ScarabException, TorqueException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionCanNotStartActivitySet);
        }
        
        if (this.activitySet == null) 
        {
            this.activitySet = activitySet;
        }
        else
        {
            throw new ScarabException(L10NKeySet.ExceptionActivitySetInProgress);
        }
/*
This is wrong. It prevented the old/new value stuff from working properly!
If we have an existing issue and we change some attributes, then when the
history was created, the data was not valid in it for some reason. I'm not
quite sure why this was added. (JSS)

Leaving here so that John can remove or fix.

        oldOptionIdIsSet = false;
        oldValueIsSet = false;
        oldOptionId = null;
        oldValue = null;
*/

        // Check for previous active activities on this attribute 
        // If they exist, set old value for this activity
        List result = null;
        final Issue issue = getIssue();
        if (issue != null)
        {
            result = issue
                .getActivitiesWithNullEndDate(getAttribute());
        }
        if (result != null && result.size() > 0)
        {
            for (int i=0; i<result.size(); i++)
            {
                final Activity a = (Activity)result.get(i);
                oldOptionId = a.getNewOptionId();
                oldValue = a.getNewValue();
            }
        }
        if (chainedValue != null) 
        {
            chainedValue.startActivitySet(activitySet);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
private void checkActivitySet(LocalizationKey l10nKey)
        throws ScarabException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(l10nKey);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setOptionIds(final Integer[] ids)
        throws TorqueException, ScarabException
    {
        if (ids != null && ids.length > 0) 
        {
            setOptionId(ids[0]);
        }
        if (ids != null && ids.length > 1) 
        {
            for (int i=1; i<ids.length; i++) 
            {            
                final AttributeValue av = AttributeValue                
                    .getNewInstance(getAttributeId(), getIssue());
                setChainedValue(av);
                av.setOptionId(ids[i]);
            }
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public Integer[] getUserIds()
        throws ScarabException
    {
        throw new ScarabException(L10NKeySet.ExceptionGetUserIdsNotImplemented);
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setUserIds(final Integer[] ids)
        throws TorqueException, ScarabException
    {
        if (ids != null && ids.length > 0) 
        {
            setUserId(ids[0]);
        }
        if (ids != null && ids.length > 1) 
        {
            for (int i=1; i<ids.length; i++) 
            {            
                final AttributeValue av = AttributeValue                
                    .getNewInstance(getAttributeId(), getIssue());
                setChainedValue(av);
                av.setUserId(ids[i]);
            }
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public boolean isRequired()
       throws TorqueException, ScarabException
    {
        return getRModuleAttribute().getRequired();
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public RModuleAttribute getRModuleAttribute()
        throws TorqueException, ScarabException
    {
        final Issue issue = getIssue();
        RModuleAttribute rma = null;
        if (issue != null)
        {
            final Module module = issue.getModule();
            if (module != null)
            {
                rma = module.getRModuleAttribute(
                    getAttribute(), getIssue().getIssueType());
            }
            else
            {
                throw new ScarabException (L10NKeySet.ExceptionGeneral,
                        "Module is null: Please report this issue."); //EXCEPTION
            }
        }
        else
        {
            throw new ScarabException (L10NKeySet.ExceptionGeneral,
                    "Issue is null: Please report this issue."); //EXCEPTION
        }
        return rma;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonLeafRModuleOptions(final Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getLeafRModuleOptions(
                attribute,
                item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleOptionTree(Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getOptionTree(attribute, item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }  
        catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
    }
            
// in java/org/tigris/scarab/om/Query.java
public boolean saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped query, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        Exception exception=null; // temporary store a thrown exception

        if (getScopeId().equals(Scope.PERSONAL__PK) 
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        }
        else
        {
            setApproved(false);

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");

                final ScarabUser[] toUsers = module
                    .getUsers(ScarabSecurity.ITEM__APPROVE);

                if (Log.get().isDebugEnabled()) 
                {
                    if (toUsers == null || toUsers.length ==0) 
                    {
                        Log.get().debug("No users to approve query.");    
                    }
                    else 
                    {
                        Log.get().debug("Users to approve query: ");    
                        for (int i=0; i<toUsers.length; i++) 
                        {
                            Log.get().debug(toUsers[i].getEmail());
                        }  
                    }          
                }
                
                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewQueryRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx,
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null,
                        template);
                }
                catch (Exception e)
                {
                    exception = e;
                }
            }
        }
        if (getMITList() != null) 
        {
            getMITList().save();
            // it would be good if this updated our list id, but it doesn't
            // happen automatically so reset it.
            setMITList(getMITList());            
        }
        save();
        if(exception != null)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral, exception);
        }
        return true;
    }
            
// in java/org/tigris/scarab/om/Query.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/Query.java
public void delete(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module)
          || (user.getUserId().equals(getUserId()) 
             && getScopeId().equals(Scope.PERSONAL__PK)))
        {
            // Delete user-query maps.
            final List rqus = getRQueryUsers();
            for (int i=0; i<rqus.size(); i++)
            {
                final RQueryUser rqu = (RQueryUser)rqus.get(i);
                rqu.delete(user);
            }
            setDeleted(true);
            save();
            
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final ActivitySetType tt, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return getInstance(tt.getTypeId(), user, null);
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final ActivitySetType tt, 
            final ScarabUser user, 
            final Attachment attachment)
        throws TorqueException, ScarabException
    {
        return getInstance(tt.getTypeId(), user, attachment);
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
            final ScarabUser user)
        throws TorqueException,ScarabException
    {
        return getInstance(typeId, user, null);
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
                                          final ScarabUser user, 
                                          final Attachment attachment)
        throws TorqueException,ScarabException
    {
        if (attachment != null && attachment.getAttachmentId() == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNeedToSaveAttachement);
        }
        final ActivitySet activitySet = new ActivitySet();
        activitySet.setTypeId(typeId);
        activitySet.setCreatedBy(user.getUserId());
        activitySet.setCreatedDate(new Date());
        if (attachment != null && 
            attachment.getData() != null &&
            attachment.getData().length() > 0)
        {
            activitySet.setAttachment(attachment);
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void delete()
         throws TorqueException, ScarabException
    {                
         delete(false);
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
protected void delete(final boolean overrideLock)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        final IssueType issueType = IssueTypeManager
           .getInstance(getIssueTypeId(), false);
        if (issueType.getLocked() && !overrideLock)
        { 
            throw new ScarabException(L10NKeySet.CannotDeleteAttributeFromLockedIssueType);
        }            
        else
        {
            final Criteria c = new Criteria()
                .add(RModuleAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleAttributePeer.doDelete(c);
            final Attribute attr = getAttribute();
            String attributeType = null;
            attributeType = (attr.isUserAttribute() ? Module.USER : Module.NON_USER);
            module.getRModuleAttributes(getIssueType(), false, attributeType)
                                        .remove(this);
            WorkflowFactory.getInstance().deleteWorkflowsForAttribute(
                                          attr, module, getIssueType());

            // delete module-user-attribute mappings
            final Criteria crit = new Criteria()
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attr.getAttributeId())
                .add(RModuleUserAttributePeer.MODULE_ID, 
                     getModuleId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                     getIssueTypeId());
            RModuleUserAttributePeer.doDelete(crit);

            // delete module-option mappings
            if (attr.isOptionAttribute())
            {
                final List optionList = module.getRModuleOptions(attr, 
                                  IssueTypePeer.retrieveByPK(getIssueTypeId()), 
                                  false);
                if (optionList != null && !optionList.isEmpty())
                {
                    final List optionIdList =
                        new ArrayList(optionList.size());
                    for (int i = 0; i < optionList.size(); i++)
                    { 
                        optionIdList.add(((RModuleOption)
                                          optionList.get(i))
                                         .getOptionId());
                    }
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID, getModuleId())
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,
                             getIssueTypeId())
                        .addIn(RModuleOptionPeer.OPTION_ID, optionIdList);
                    RModuleOptionPeer.doDelete(c2);
                }
            }
        }

        RModuleAttributeManager.removeInstanceFromCache(this);
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public void delete()
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

            final IssueType issueType = IssueTypeManager
               .getInstance(getIssueTypeId(), false);
            if (issueType.getLocked())
            { 
                throw new ScarabException(L10NKeySet.ExceptionDeleteOptionFromLockedIssueType);
            }            
            else
            {
                Integer moduleId    = getModuleId();
                Integer issueTypeId = getIssueTypeId();
                Integer optionId    = getOptionId();
                int orderNumber     = getOrder();

                // delete the option
                final Criteria c = new Criteria()
                    .add(RModuleOptionPeer.MODULE_ID, moduleId)
                    .add(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId)
                    .add(RModuleOptionPeer.OPTION_ID, optionId);
                RModuleOptionPeer.doDelete(c);
                
                // delete associated workflow
                WorkflowFactory.getInstance().deleteWorkflowsForOption(getAttributeOption(), 
                                             module, issueType);

                // ======================================================
                // Correct the ordering of the remaining options
                // ======================================================

                // first retrieve the list of still available option ids
                final List optIds = new ArrayList();
                final List rmos = module.getRModuleOptions(getAttributeOption().getAttribute(), issueType, false);
                for (int i=0; i<rmos.size();i++)
                {
                    final RModuleOption rmo = (RModuleOption)rmos.get(i);
                    optIds.add(rmo.getOptionId());
                }
               
                // Need to perform the correction only if the deleted option had follow up options
                if(optIds.size() > 0)
                {
                    // update the list
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID,       moduleId)
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,   issueTypeId)
                        .addIn(RModuleOptionPeer.OPTION_ID,     optIds)
                        .add(RModuleOptionPeer.PREFERRED_ORDER, orderNumber, Criteria.GREATER_THAN);
                    final List adjustRmos = RModuleOptionPeer.doSelect(c2);
                    for (int j=0; j<adjustRmos.size();j++)
                    {
                        final RModuleOption rmo = (RModuleOption)adjustRmos.get(j);
                        //rmos.remove(rmo);
                        rmo.setOrder(rmo.getOrder() -1);
                        rmo.save();
                        //rmos.add(rmo);
                    }
                }
            }
            // notify module cache of this change
            ((ModuleManager)Torque.getManager(ModuleManager.MANAGED_CLASS))
                .refreshedObject(this);
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getInstanceByEmail(final String email) 
        throws TorqueException,ScarabException
    {
        return getManager().getInstanceByEmailImpl(email);
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected ScarabUser getInstanceByEmailImpl(final String email) 
        throws TorqueException,ScarabException
    {
        ScarabUser user = null;
        if (email != null) 
        {
            final Criteria crit = new Criteria();
            crit.add(ScarabUserImplPeer.EMAIL, email);
            final List users = ScarabUserImplPeer.doSelect(crit);
            if (users.size() == 1) 
            {
                user = (ScarabUser)users.get(0);
            }
            else if (users.size() > 1) 
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateUsername); 
            }
        }
        return user;
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public void save()
        throws TorqueException, ScarabException
    {
        AttributeOption ao = null;
        ROptionOption roo = null;

        final Attribute tmpAttr = AttributeManager.getInstance(getAttributeId());
        
        // if it is new, it won't already have an optionId
        if (getOptionId() == null)
        {
            // if it is new, check for duplicates.
            final AttributeOption duplicate = 
                AttributeOptionManager.getInstance(tmpAttr, getName().trim());
            final AttributeOption parent = 
                AttributeOptionManager.getInstance(getParentId());
            if (duplicate != null)
            {
                throw new ScarabException (new L10NKey("CannotCreateDuplicateOption")); //EXCEPTION
            }
            else if (parent.getDeleted())
            {
                throw new ScarabException (new L10NKey("CannotCreateChild")); //EXCEPTION
            }
        }

        // if getOptionId() is null, then it will just create a new instance
        final Integer optionId = getOptionId();
        if (optionId == null)
        {
            ao = AttributeOptionManager.getInstance();
        } 
        else
        {
            ao = AttributeOptionManager.getInstance(getOptionId());
        }

        
        ao.setName(getName());
        ao.setDeleted(getDeleted());
        ao.setAttribute(tmpAttr);
        ao.setStyle(getStyle());
        ao.save();

        // clean out the caches for the AO
        tmpAttr.doRemoveCaches();

        // now set our option id from the saved AO
        this.setOptionId(ao.getOptionId());

        // now create the ROO mapping
        try
        {
            // look for a cached ROptionOption
            roo = ROptionOption.getInstance(getParentId(), getOptionId());
        }
        catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
        roo.setPreferredOrder(getPreferredOrder());
        roo.setWeight(getWeight());
        roo.setRelationshipId(OptionRelationship.PARENT_CHILD);
        roo.save();
    }
            
// in java/org/tigris/scarab/om/ROptionOption.java
public static ROptionOption getInstance(final Integer parent, final Integer child)
        throws ScarabException
    {
    	ROptionOption option = null;
    	try
        {
    	    final Criteria crit = new Criteria();
            crit.add (ROptionOptionPeer.OPTION1_ID, parent);
            crit.add (ROptionOptionPeer.OPTION2_ID, child);
            option = (ROptionOption) (ROptionOptionPeer.doSelect(crit)).get(0);
        }
        catch (Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionOptionNotFound,
                                      parent.toString(),
                                      child.toString());
        }
        return option;
    }
            
// in java/org/tigris/scarab/om/ActivitySetType.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException, ScarabException
    {
        return ActivitySetTypeManager.getInstance(activitySetTypeName);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public IssueType getTemplateIssueType()
        throws TorqueException, ScarabException
    {
        if (templateIssueType == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.PARENT_ID, getIssueTypeId());
            final List results = IssueTypePeer.doSelect(crit);
            if (results.isEmpty())
            {
                throw new ScarabException(L10NKeySet.ExceptionTemplateTypeForIssueType);
            }
            else
            {
                templateIssueType = (IssueType)results.get(0);
            }
        }
        return templateIssueType;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public Integer getTemplateId()
        throws TorqueException, ScarabException
    {
        return getTemplateIssueType().getIssueTypeId();
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public static IssueType getInstance(final String issueTypeName)
        throws TorqueException,ScarabException
    {
        IssueType result = null;
        Object obj = ScarabCache.get(ISSUE_TYPE, GET_INSTANCE, issueTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.NAME, issueTypeName);
            final List issueTypes = IssueTypePeer.doSelect(crit);
            if(issueTypes == null || issueTypes.size() == 0)
            {
                throw new ScarabException(L10NKeySet.ExceptionInvalidIssueType,
                                          issueTypeName);
            }
            result = (IssueType)issueTypes.get(0);
            ScarabCache.put(result, ISSUE_TYPE, GET_INSTANCE, issueTypeName);
        }
        else 
        {
            result = (IssueType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public IssueType copyIssueType()
        throws TorqueException, ScarabException
    {
        final IssueType newIssueType = new IssueType();
        newIssueType.setName(getName() + " (copy)");
        newIssueType.setDescription(getDescription());
        newIssueType.setParentId(ScarabConstants.INTEGER_0);
        newIssueType.save();
        final Integer newId = newIssueType.getIssueTypeId();

        // Copy template type
        final IssueType template = IssueTypePeer
              .retrieveByPK(getTemplateId());
        final IssueType newTemplate = new IssueType();
        newTemplate.setName(template.getName());
        newTemplate.setParentId(newId);
        newTemplate.save();

        // Copy user attributes
        final List userRIAs = getRIssueTypeAttributes(false, USER);
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            final RIssueTypeAttribute newUserRia = userRia.copyRia();
            newUserRia.setIssueTypeId(newId);
            newUserRia.save();
        }

        // Copy attribute groups
        final List attrGroups = getAttributeGroups(false);
        for (int i = 0; i<attrGroups.size(); i++)
        {
            final AttributeGroup group = (AttributeGroup)attrGroups.get(i);
            final AttributeGroup newGroup = group.copyGroup();
            newGroup.setIssueTypeId(newId);
            newGroup.save();

            // add attributes
            final List attrs = group.getAttributes();
            if (attrs != null)
            {
                for (int j=0; j<attrs.size(); j++)
                {
                    // save attribute-attribute group maps
                    final Attribute attr = (Attribute)attrs.get(j);
                    final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                    final RAttributeAttributeGroup newRaag = new RAttributeAttributeGroup();
                    newRaag.setAttributeId(raag.getAttributeId());
                    newRaag.setOrder(raag.getOrder());
                    newRaag.setGroupId(newGroup.getAttributeGroupId());
                    newRaag.save();

                    // save attribute-issueType maps
                    final RIssueTypeAttribute ria = getRIssueTypeAttribute(attr);
                    final RIssueTypeAttribute newRia = ria.copyRia();
                    newRia.setIssueTypeId(newId);
                    newRia.save();

                    // save options
                    final List rios = getRIssueTypeOptions(attr, false);
                    if (rios != null)
                    {
                        for (int k=0; k<rios.size(); k++)
                        {
                            final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                            final RIssueTypeOption newRio = rio.copyRio();
                            newRio.setIssueTypeId(newId);
                            newRio.save();
                        }
                    }
                }
            }
        }

        // add workflow 
        WorkflowFactory.getInstance().copyIssueTypeWorkflows(this, newIssueType);

        return newIssueType;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public void deleteModuleMappings(final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                 getIssueTypeId());
        final List rmits = RModuleIssueTypePeer.doSelect(crit);
        for (int i=0; i<rmits.size(); i++)
        {
            final RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
            rmit.delete(user);
        }
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean canCreateIssueInScope(ScarabUser user, Module module) throws TorqueException, ScarabException
    {
        //[HD first check, if user has IssueCreate permission in this module
        boolean isPermissionGranted = user.hasPermission(ScarabSecurity.ISSUE__ENTER, module);
        
        if(isPermissionGranted)
        {
            List requiredAttributes = getRequiredAttributes(module);
            Iterator iter = requiredAttributes.iterator();
            while(iter.hasNext())
            {
                Attribute attribute = (Attribute)iter.next();
                Workflow workflow = WorkflowFactory.getInstance();
                if(attribute.isOptionAttribute())
                {
                    boolean canDoPartial = workflow.canMakeTransitionsFrom(user, this, attribute, null);
                    if(!canDoPartial)
                    {
                        isPermissionGranted = false;
                        break;
                    }
                }
            }
        }
        return isPermissionGranted;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean canCreateAttributeInScope(ScarabUser user, Module module, Attribute attribute) throws TorqueException, ScarabException
    {
        boolean result = true;
        Workflow workflow = WorkflowFactory.getInstance();
        if(attribute.isOptionAttribute())
        {
            result = workflow.canMakeTransitionsFrom(user, this, attribute, null);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user)
        throws ScarabException
    {
        int count = 0;
        try 
        {
            IssueSearch is = IssueSearchFactory.INSTANCE
                .getInstance(getModule(), getIssueType(), user);
            count = is.getIssueCount();
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
        return count;
    }
            
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user, AttributeOption attributeOption)
        throws TorqueException, ScarabException, DataSetException
    {
        Criteria crit = new Criteria();

        Integer attributeId = attributeOption.getAttributeId();
        Integer optionId    = attributeOption.getOptionId();

        crit.add(AttributeValuePeer.ATTRIBUTE_ID, attributeId);
        crit.add(AttributeValuePeer.OPTION_ID,optionId);
        crit.add(AttributeValuePeer.DELETED,0);
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.TYPE_ID,this.getIssueTypeId());
        crit.add(IssuePeer.MOVED, 0);
        crit.add(IssuePeer.DELETED, 0);
        crit.addJoin(AttributeValuePeer.ISSUE_ID, IssuePeer.ISSUE_ID);

        int count = AttributeValuePeer.count(crit);
        return count;
    }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(NotificationStatus notif) throws ScarabException
    {
        NotificationRule rule = null;
        try
        {
            Long issueId = notif.getIssueId();
            Issue issue = IssueManager.getInstance(issueId);
            Integer moduleId = issue.getModuleId();
            Integer userId = notif.getReceiverId();
            ActivityType activityType = notif.getActivityType();
            rule = getNotificationRule(moduleId, userId, activityType.getCode());
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
        return rule;
    }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(Integer moduleId, Integer userId, String activityType) throws ScarabException
    {
        NotificationRule rule = null;
        
        int managerId = NotificationManagerFactory.getInstance().getManagerId();
        Criteria crit = new Criteria();
        crit.add(NotificationRulePeer.USER_ID, userId);
        crit.add(NotificationRulePeer.MODULE_ID, moduleId);
        crit.add(NotificationRulePeer.ACTIVITY_TYPE, activityType);
        crit.add(NotificationRulePeer.MANAGER_ID, managerId);
                
        try
        {
            List<NotificationRule> ruleSet = (List<NotificationRule>)NotificationRulePeer.doSelect(crit);     
            if(ruleSet == null || ruleSet.size()==0)
            {

                rule = NotificationRule.createDefaultRule( 
                       moduleId, 
                       userId,
                       managerId,
                       activityType);
            }
            else if (ruleSet.size() > 1)
            {
                String msg = "Database inxonsistency:"
                           + " Expected at most one key matching (user_id,module_id,activity_type,manager_id) = "
                           + ")" + userId + "," + moduleId + "," + activityType + "," + managerId + ")";
                throw new TorqueException(msg,new Throwable());
            }
            else
            {
                rule = ruleSet.get(0);
            }
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }

        return rule;
    }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static boolean isNotificationEnabledFor(ScarabUser user, Issue issue, boolean isSelf, String activityType, ActivitySet activitySet) throws ScarabException, TorqueException
    {
        Integer userId   = user.getUserId();
        Module module    = issue.getModule();
        Integer moduleId = module.getModuleId();
        
        NotificationRule rule = getNotificationRule(moduleId, userId, activityType);
        boolean isEnabled;
        if(isSelf)
        {
            isEnabled = rule.getSendSelf();
        }
        else
        {
            if(issue.isSealed() && !activitySet.hasTransitionSealed())
            {
                isEnabled = false; // Do not send notifications to other users when Issue is "closed"
            }
            else
            {
                isEnabled = rule.getFilterState();
            }
        }
        
        if(isEnabled)
        {
            Notification notification = new Notification(user, issue);
            isEnabled = notification.sendConditionsMatch();
        }
        return isEnabled;
    }
            
// in java/org/tigris/scarab/om/RIssueTypeOption.java
public void delete(final ScarabUser user, final Module module)
         throws TorqueException, ScarabException
    {                
        if (user.hasPermission(ScarabSecurity.DOMAIN__EDIT, module))
        {
            final List rios = getIssueType().getRIssueTypeOptions(
                                      getAttributeOption().getAttribute(), false);
            final Criteria c = new Criteria()
                .add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
            RIssueTypeOptionPeer.doDelete(c);
            rios.remove(this);
            if (rios.size() > 0)
            {
                // Correct the ordering of the remaining options
                final ArrayList optIds = new ArrayList();
                for (int i=0; i<rios.size();i++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)rios.get(i);
                    optIds.add(rio.getOptionId());
                }
                final Criteria c2 = new Criteria()
                    .addIn(RIssueTypeOptionPeer.OPTION_ID, optIds)
                    .add(RIssueTypeOptionPeer.PREFERRED_ORDER, getOrder(), 
                         Criteria.GREATER_THAN);
                final List adjustRios = RIssueTypeOptionPeer.doSelect(c2);
                for (int j=0; j<adjustRios.size();j++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)adjustRios.get(j);
                    rio.setOrder(rio.getOrder() -1);
                    rio.save();
                }
            }
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public ScarabUser[] getEligibleUsers(Attribute attribute)
        throws TorqueException,ScarabException
    {
        ScarabUser[] users = null;
        if (attribute.isUserAttribute()) 
        {
            String permission = attribute.getPermission();
            if (permission == null) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionNoAttributePermission,
                        attribute.getName());
            }
            else 
            {
                users = getUsers(permission);
            }
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getSavedReports(final ScarabUser user)
        throws TorqueException,ScarabException
    {
        List reports = null;
        final Object obj = ScarabCache.get(this, GET_SAVED_REPORTS, user); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria()
                .add(ReportPeer.DELETED, 0);
            final Criteria.Criterion cc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.MODULE__PK, Criteria.EQUAL);
            cc.and(crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL));
            final Criteria.Criterion personalcc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.PERSONAL__PK, Criteria.EQUAL);
            personalcc.and(crit.getNewCriterion(
                ReportPeer.USER_ID, user.getUserId(), Criteria.EQUAL));
            final Criteria.Criterion personalmodulecc = crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL);
            personalmodulecc.or(crit.getNewCriterion(
                ReportPeer.MODULE_ID, null, Criteria.EQUAL));
            personalcc.and(personalmodulecc);
            cc.or(personalcc);
            crit.add(cc);
            crit.addAscendingOrderByColumn(ReportPeer.SCOPE_ID);
            final List torqueReports = ReportPeer.doSelect(crit);      
            // create ReportBridge's from torque Reports.
            if (!torqueReports.isEmpty()) 
            {
                reports = new ArrayList(torqueReports.size());
                for (Iterator i = torqueReports.iterator(); i.hasNext();) 
                {
                    final Report torqueReport = (Report)i.next();
                    try 
                    {
                        reports.add( new ReportBridge(torqueReport) );
                    }
                    catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }     
                    catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
                }
            }
            else 
            {
                reports = Collections.EMPTY_LIST;
            }

            ScarabCache.put(reports, this, GET_SAVED_REPORTS, user);
        }
        else 
        {
            reports = (List)obj;
        }
        return reports;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleAttribute addRModuleAttribute(final IssueType issueType,
                                                final Attribute attribute)
        throws TorqueException, ScarabException
    {
        String attributeType = null;
        attributeType = (attribute.isUserAttribute() ? USER : NON_USER);

        final RModuleAttribute rma = new RModuleAttribute();
        rma.setModuleId(getModuleId());
        rma.setIssueTypeId(issueType.getIssueTypeId());
        rma.setAttributeId(attribute.getAttributeId());
        rma.setOrder(getLastAttribute(issueType, attributeType) + 1);
        rma.setConditionsArray(attribute.getConditionsArray(), attribute.getConditionOperator());
        rma.save();
        getRModuleAttributes(issueType, false, attributeType).add(rma);

        // Add to template type
        final IssueType templateType = IssueTypeManager
            .getInstance(issueType.getTemplateId(), false);
        final RModuleAttribute rma2 = new RModuleAttribute();
        rma2.setModuleId(getModuleId());
        rma2.setIssueTypeId(templateType.getIssueTypeId());
        rma2.setAttributeId(attribute.getAttributeId());
        rma2.setOrder(getLastAttribute(templateType, attributeType) + 1);
        rma2.save();
        return rma;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAllAttributeOptions(Integer attributeId)
            throws TorqueException, ScarabException
    {
        List result;
        if (attributeId == null)
        {
            this.getLog().warn(
                    "No attribute specified while fetching attribute options.");
            result = Collections.EMPTY_LIST;
        } else
        {
            int id = attributeId.intValue();
            Attribute attribute = Attribute.getInstance(id);
            if (attribute == null)
            {
                this.getLog().warn(
                        "No options found for Attribute [" + attributeId + "]");
                // L10NMessage msg = new
                // L10NMessage(L10NKeySet.AttributeNotInSession,""+attributeId);
                // throw new ScarabException(msg);
                result = Collections.EMPTY_LIST;
            } else
            {
                // Integer attributeId = attribute.getAttributeId();

                Criteria crit = new Criteria();
                crit.add(AttributeOptionPeer.ATTRIBUTE_ID, attributeId);
                crit.add(AttributeOptionPeer.DELETED, false);
                result = AttributeOptionPeer.doSelect(crit);
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addAttributeOption(final IssueType issueType, 
            final AttributeOption option)
        throws TorqueException, ScarabException
    {
        final RModuleOption rmo = addRModuleOption(issueType, option);
        rmo.save();
        shiftAttributeOption(option.getAttribute(), issueType, rmo.getOrder());

        // add module-attributeoption mappings to template type
        final IssueType templateType = IssueTypeManager
                 .getInstance(issueType.getTemplateId());
        final RModuleOption rmo2 = addRModuleOption(templateType, option);
        rmo2.save();
        //FIXME: is it useful to shift options for the templateType?
        //shiftAttributeOption(option.getAttribute(), templateType, rmo.getOrder());
        
        //if the cache is not cleared, when two options are added at the same time, 
        //getLastAttributeOption does not take into account the newest active options.
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void setRmaBasedOnIssueType(final RIssueTypeAttribute ria)
        throws TorqueException, ScarabException
    {
        final RModuleAttribute rma = new RModuleAttribute(); 
        rma.setModuleId(getModuleId());
        rma.setIssueTypeId(ria.getIssueTypeId());
        rma.setAttributeId(ria.getAttributeId());
        rma.setActive(ria.getActive());
        rma.setRequired(ria.getRequired());
        rma.setOrder(ria.getOrder());
        rma.setQuickSearch(ria.getQuickSearch());
        rma.setDefaultTextFlag(ria.getDefaultTextFlag());
        rma.save();
        final RModuleAttribute rma2 = rma.copy();
        rma2.setModuleId(getModuleId());
        rma2.setIssueTypeId(ria.getIssueType().getTemplateId());
        rma2.setAttributeId(ria.getAttributeId());
        rma2.setActive(ria.getActive());
        rma2.setRequired(ria.getRequired());
        rma2.setOrder(ria.getOrder());
        rma2.setQuickSearch(ria.getQuickSearch());
        rma2.setDefaultTextFlag(ria.getDefaultTextFlag());
        rma2.save();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void setRmoBasedOnIssueType(final RIssueTypeOption rio)
        throws TorqueException, ScarabException
    {
        final RModuleOption rmo = new RModuleOption(); 
        rmo.setModuleId(getModuleId());
        rmo.setIssueTypeId(rio.getIssueTypeId());
        rmo.setOptionId(rio.getOptionId());
        rmo.setActive(rio.getActive());
        rmo.setOrder(rio.getOrder());
        rmo.setWeight(rio.getWeight());
        rmo.save();
        final RModuleOption rmo2 = rmo.copy();
        rmo2.setModuleId(getModuleId());
        rmo2.setIssueTypeId(rio.getIssueType().getTemplateId());
        rmo2.setOptionId(rio.getOptionId());
        rmo2.setActive(rio.getActive());
        rmo2.setOrder(rio.getOrder());
        rmo2.setWeight(rio.getWeight());
        rmo2.save();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getTemplateTypes()
        throws TorqueException, ScarabException
    {
        List templateTypes = new ArrayList();
        final Object obj = ScarabCache.get(this, GET_TEMPLATE_TYPES); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                     IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.DELETED, 0);
            final List rmits = RModuleIssueTypePeer.doSelect(crit);
            for (int i=0; i<rmits.size(); i++)
            {
                final RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
                final IssueType templateType = rmit.getIssueType().getTemplateIssueType();
                templateTypes.add(templateType);
            }
            ScarabCache.put(templateTypes, this, GET_TEMPLATE_TYPES);
        }
        else 
        {
            templateTypes = (List)obj;
        }
        return templateTypes;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void setInitialAttributesAndIssueTypes()
        throws TorqueException, DataSetException, ScarabException
    {
        isInitializing = true;
        ValidationException ve = null;
        try
        {
        // Add defaults for issue types and attributes 
        // from parent module
        final Module parentModule = ModuleManager.getInstance(getParentId());
        if(parentModule != null && parentModule.getModuleId().intValue() != 0){
        	inheritFromParent(parentModule);  //don't inherit anything from global data/module
        }
        
        final List defaultIssueTypes = IssueTypePeer.getDefaultIssueTypes();
        for (int i=0; i< defaultIssueTypes.size(); i++)
        {
            final IssueType defaultIssueType = (IssueType)defaultIssueTypes.get(i);
            if (!includesIssueType(defaultIssueType))
            {
                try
                {
                    addIssueType(defaultIssueType);
                }
                catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
            }
        }
        }
        finally
        {
            isInitializing = false;
        }
        if (ve != null) 
        {
            throw ve;
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void inheritFromParent(final Module parentModule)
        throws TorqueException, ScarabException
    {
        final Integer newModuleId = getModuleId();
        AttributeGroup ag1;
        AttributeGroup ag2;
        RModuleAttribute rma1 = null;
        RModuleAttribute rma2 = null;
            
        //save RModuleAttributes for template types.
        final List templateTypes = parentModule.getTemplateTypes();
        for (int i=0; i<templateTypes.size(); i++)
        {
            final IssueType it = (IssueType)templateTypes.get(i);
            final List rmas = parentModule.getRModuleAttributes(it);
            for (int j=0; j<rmas.size(); j++)
            {
                rma1 = (RModuleAttribute)rmas.get(j);
                rma2 = rma1.copy();
                rma2.setModuleId(newModuleId);
                rma2.setAttributeId(rma1.getAttributeId());
                rma2.setIssueTypeId(rma1.getIssueTypeId());
                getLog().debug("[ASM] Saving rma for new template type: " + 
                                    rma2.getModuleId()
                                    + "-" + rma2.getIssueTypeId() + "-" +
                                    rma2.getAttributeId());
                rma2.save();
            }
        }

        // set module-issue type mappings
        final List rmits = parentModule.getRModuleIssueTypes();
        for (int i=0; i<rmits.size(); i++)
        {
            final RModuleIssueType rmit1 = (RModuleIssueType)rmits.get(i);
            final RModuleIssueType rmit2 = rmit1.copy();
            rmit2.setModuleId(newModuleId);
            rmit2.save();
            final IssueType issueType = rmit1.getIssueType();

            // set attribute group defaults
            final List attributeGroups = issueType
                .getAttributeGroups(parentModule, true);
            for (int j=0; j<attributeGroups.size(); j++)
            {
                ag1 = (AttributeGroup)attributeGroups.get(j);
                ag2 = ag1.copy();
                ag2.setModuleId(newModuleId);
                ag2.getRAttributeAttributeGroups().clear();    // are saved later
                ag2.save();

                final List attributes = ag1.getAttributes();
                for (int k=0; k<attributes.size(); k++)
                {
                    final Attribute attribute = (Attribute)attributes.get(k);

                    // set attribute-attribute group defaults
                    final RAttributeAttributeGroup raag1 = ag1
                        .getRAttributeAttributeGroup(attribute);
                    final RAttributeAttributeGroup raag2 = raag1.copy();
                    raag2.setGroupId(ag2.getAttributeGroupId());
                    raag2.setAttributeId(raag1.getAttributeId());
                    raag2.setOrder(raag1.getOrder());
                    raag2.save();
                }
            }

            // set module-attribute defaults
            final List rmas = parentModule.getRModuleAttributes(issueType);
            if (rmas != null && rmas.size() >0)
            {
                for (int j=0; j<rmas.size(); j++)
                {
                    rma1 = (RModuleAttribute)rmas.get(j);
                    rma2 = rma1.copy();
                    rma2.setModuleId(newModuleId);
                    rma2.setAttributeId(rma1.getAttributeId());
                    rma2.setIssueTypeId(rma1.getIssueTypeId());
                    rma2.save();

                    // set module-option mappings
                    final Attribute attribute = rma1.getAttribute();
                    if (attribute.isOptionAttribute())
                    {
                        final List rmos = parentModule.getRModuleOptions(attribute,
                                                                   issueType);
                        if (rmos != null && rmos.size() > 0)
                        {
                            for (int m=0; m<rmos.size(); m++)
                            {
                                final RModuleOption rmo1 = (RModuleOption)rmos.get(m);
                                final RModuleOption rmo2 = rmo1.copy();
                                rmo2.setOptionId(rmo1.getOptionId());
                                rmo2.setModuleId(newModuleId);
                                rmo2.setIssueTypeId(issueType.getIssueTypeId());
                                rmo2.save();

                                // Save module-option mappings for template types
                                final RModuleOption rmo3 = rmo1.copy();
                                rmo3.setOptionId(rmo1.getOptionId());
                                rmo3.setModuleId(newModuleId);
                                rmo3.setIssueTypeId(issueType.getTemplateId());
                                rmo3.save();
                            }
                        }
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public void deleteModuleMappings()
        throws TorqueException, ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID,
                 getAttributeId());
        crit.addJoin(RAttributeAttributeGroupPeer.GROUP_ID,
                     AttributeGroupPeer.ATTRIBUTE_GROUP_ID);
        crit.add(AttributeGroupPeer.MODULE_ID, (Object)null, Criteria.NOT_EQUAL);
        final List raags = RAttributeAttributeGroupPeer.doSelect(crit);
        for (Iterator i = raags.iterator(); i.hasNext();)
        {
            ((RAttributeAttributeGroup)i.next()).delete();
        }

        crit = new Criteria();
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID, 
                 getAttributeId());
        final List rmas = RModuleAttributePeer.doSelect(crit);
        for (int i=0; i<rmas.size(); i++)
        {
            final RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
            rma.delete(true);
        }
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/ActivitySetTypeManager.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException,ScarabException
    {
        ActivitySetType ttype = null; 
        Object obj = ScarabCache.get(TRANSACTION_TYPE, GET_INSTANCE, 
                                     activitySetTypeName);
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(ActivitySetTypePeer.NAME, activitySetTypeName);
            final List activitySetTypes = ActivitySetTypePeer.doSelect(crit);
            if (activitySetTypes.size() < 1) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetTypenameNotFound, 
                        activitySetTypeName);
            }
            if (activitySetTypes.size() > 1)
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetDuplicateTypename,
                        activitySetTypeName);
            }
            ttype = (ActivitySetType)activitySetTypes.get(0);
            ScarabCache.put(ttype, "ActivitySetType", "getInstance", 
                            activitySetTypeName);
        }
        else 
        {
            ttype = (ActivitySetType)obj;
        }
        
        return ttype;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addUrl(final Attachment attachment, final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return addUrl(null, attachment, user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addUrl(ActivitySet activitySet, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        attachment.setTextFields(user, this, Attachment.URL__PK);
        attachment.save();

        activitySet = attachActivitySet(activitySet, user);

        // Save activity record
        ActivityManager
            .createTextActivity(this, activitySet, ActivityType.URL_ADDED, attachment);
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(final Attachment attachment, final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return addComment(null, attachment, user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(ActivitySet activitySet, 
                                  Attachment attachment, ScarabUser user)
        throws TorqueException, ScarabException
    {
        String comment = attachment.getData();
        if (comment == null || comment.length() == 0)
        {
            throw new ScarabException(L10NKeySet.NoDataInComment);
        }

        activitySet = attachActivitySet(activitySet, user);

        // populates the attachment with data to be a comment
        attachment = AttachmentManager
                        .getComment(attachment, this, user);

        ActivityManager
            .createTextActivity(this, activitySet,
                                ActivityType.COMMENT_ADDED, attachment);

        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.COMMENT_ADDED, activitySet, this, user);            

        index();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public synchronized ActivitySet doSaveFileAttachments(final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return doSaveFileAttachments(null, user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public synchronized ActivitySet doSaveFileAttachments(ActivitySet activitySet,
                                                          final ScarabUser user)
        throws TorqueException, ScarabException
    {
        if (unSavedAttachments == null)
        {
            return activitySet;
        }
        activitySet = attachActivitySet(activitySet, user);

        final Iterator itr = unSavedAttachments.iterator();
        while (itr.hasNext())
        {
            final Attachment attachment = (Attachment)itr.next();
            // make sure we set the issue to the newly created issue
            attachment.setIssue(this);
            attachment.save();

            // Save activity record
            ActivityManager
                .createTextActivity(this, activitySet, ActivityType.ATTACHMENT_CREATED, attachment);

           
        }
        // reset the super method so that the query has to hit the database again
        // so that all of the information is cleaned up and reset.
        super.collAttachments = null;
        // we don't need this one anymore either.
        this.unSavedAttachments = null;
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getEligibleUsers(Attribute attribute)
        throws TorqueException, ScarabException
    {
        ScarabUser[] users = getModule().getEligibleUsers(attribute);
        // remove those already assigned
        List assigneeAVs = getAttributeValues(attribute);
        if (users != null && assigneeAVs != null) 
        {        
            for (int i=users.length-1; i>=0; i--) 
            {
                for (int j=assigneeAVs.size()-1; j>=0; j--) 
                {
                    AttributeValue av = (AttributeValue)assigneeAVs.get(j);
                    Integer avUserId = av.getUserId();
                    Integer userUserId = users[i].getUserId();
                    if ( av != null && avUserId != null && 
                         userUserId != null && 
                         avUserId.equals(userUserId))
                    {
                        users[i] = null;
                        break;
                    }
                }
            }
        }

        List eligibleUsers = new ArrayList(users.length);
        for (int i=0; i<users.length; i++) 
        {
            if (users[i] != null)
            {
                eligibleUsers.add(users[i]);
            }
        }

        return eligibleUsers;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getActivitySet(final ScarabUser user, 
            final Attachment attachment,
            final Integer type)
        throws TorqueException,ScarabException
    {
        ActivitySet activitySet = null;
        if (attachment == null)
        {
            activitySet = ActivitySetManager
                .getInstance(type, user);
        }
        else
        {
            activitySet = ActivitySetManager
                .getInstance(type, user, attachment);
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getActivitySet(ScarabUser user, Integer type)
        throws TorqueException, ScarabException
    {
        return getActivitySet(user, null, type);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doAddDependency(ActivitySet activitySet, Depend depend, 
                                       Issue childIssue, ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check whether the entered issue is already dependent on this
        // Issue. If so, then throw an exception because we don't want
        // to add it again.
        Depend prevDepend = this.getDependency(childIssue, true);
        if (prevDepend != null)
        {
            throw new ScarabException(L10NKeySet.DependencyExists);
        }

        // we definitely want to do an insert here so force it.
        depend.setNew(true);
        depend.setDeleted(false);
        depend.save();

        Attachment comment = depend.getDescriptionAsAttachment(user, this);
        activitySet = attachActivitySet(activitySet, user, comment);

        // Save activity record for the parent issue
        ActivityManager
            .createAddDependencyActivity(this, activitySet, depend);

        // Save activity record for the child issue
        ActivityManager
            .createAddDependencyActivity(childIssue, activitySet, depend);

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private int getNextIssueId(Connection con)
        throws TorqueException, ScarabException
    {
        int id = -1;
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        try
        {
            id = idbroker.getIdAsInt(con, key);
        }
        catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
        return id;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private void setNextIssueId(Connection con, int newID)
        throws TorqueException, ScarabException
    {
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        int nextID = 1;
        
        synchronized (idbroker)
        {
            try
            {
                // Check if the ID table is available and get the next ID
                nextID = idbroker.getIdAsInt(con, key);
            }
            catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }

            if (nextID > newID) {
                getLog()
                    .error("New issue ID "+ newID
                    + "is out of sequence. Must be at least " + nextID);
            }
            else
            {
                try
                {
                    // Now set the next available ID in the table
                    setIdTableKey(con, newID);
                }
                catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Issue move(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user,
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
    	
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // If moving to a new issue type, just change the issue type id
        // otherwise, create fresh issue
        if (getModule().getModuleId().equals(newModule.getModuleId())
            && !getIssueType().getIssueTypeId().equals(newIssueType.getIssueTypeId()))
        {
            newIssue = this;
            newIssue.setIssueType(newIssueType);
            newIssue.save();
        }
        else
        {
            newIssue = newModule.getNewIssue(newIssueType);
        }

        if (newIssue != this)//new issue is not same issue instance as old issue
        {
            // mark issue as moved
            setMoved(true);
            save();

            //add new transaction to new issue
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();      

            // copy attachments: comments/files etc.
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                String oldFilePath = oldA.getFullPath();
                oldA.setIssueId(newIssue.getIssueId());
                oldA.save();
                
                // move file attachment, too
                if (Attachment.FILE__PK.equals(oldA.getTypeId())
                		&& !newIssue.getUniqueId().equals(this.getUniqueId()))
                {
                    try
                    {
                        oldA.copyFileFromTo(oldFilePath, oldA.getFullPath());//copy
                        File f = new File(oldFilePath);//delete old one from disk
                        f.delete();
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }

            // Copy over activity sets for the source issue's previous,
            // and adapt them to new issue
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();

                // If activity set has an attachment, make a copy for new issue
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    // iterate over and move transaction's activities
                    final Activity a = (Activity)j.next();
                    
                    // Only copy transactions that are records of previous move/copies
                    // or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // will be saved when attachments and dependencies are copied.
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                            || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                    	att.setIssueId(newIssue.getIssueId());
                                    	att.setActivity(a);
                                    	att.startActivitySet(as);
                                    	att.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            //adapt all misc activities from old issue
            Iterator iterActivities = getActivitys().iterator();
            while(iterActivities.hasNext()){
            	Activity act = (Activity)iterActivities.next();
            	act.setIssue(newIssue);
            	act.save();
            	newIssue.getActivity(true).add(act); // ?
            }
            
            // Adjust dependencies if its a new issue id
            // (i.e.. moved to new module)
           final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
        }       
       

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "MovedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());

        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "MovedIssueNote"));
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_MOVED,
                                getUniqueId(), newIssue.getUniqueId());

        newIssue.index();
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_MOVED,
                activitySet2, newIssue, user);
        
        return newIssue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Issue copy(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user, 
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // create fresh issue
        newIssue = newModule.getNewIssue(newIssueType);

        if (newIssue != this)
        {
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();

            // Copy over activity sets for the source issue's attribute activities
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();
                ActivitySet newAS = null;
                Attachment newAtt =  null;
                              
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    final Activity a = (Activity)j.next();

                    // Only copy transactions that are records of previous move/copies
                    // Or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // Will be saved when attachments and dependencies are copied
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                        || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // iterate over and copy transaction's activities
                       
                        if(newAS == null){
                        	
                        	 // If old activity set has an attachment, make a copy for new issue
                            if (as.getAttachmentId() != null)
                            {
                                newAtt = as.getAttachment().copy();
                                newAtt.save();
                            }
                        	
            				//init and store new activity set/transaction
                            newAS = new ActivitySet();
                            newAS.setTypeId(as.getTypeId());
                            if (newAtt != null)
                            {
                                newAS.setAttachmentId(newAtt.getAttachmentId());
                            }
                            newAS.setCreatedBy(as.getCreatedBy());
                            newAS.setCreatedDate(as.getCreatedDate());
                            newAS.save();
                        }
                        
                        final Activity newA = a.copy(newIssue, newAS);
                        
                        newIssue.getActivity(true).add(newA);
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                        final AttributeValue newAttVal = att.copy();
                                        newAttVal.setIssueId(newIssue.getIssueId());                                        
                                        newAttVal.setActivity(newA);
                                        newAttVal.startActivitySet(newAS);
                                        newAttVal.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            // add dependencies newly
            final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
            // copy attachments: comments/files etc. and add them, too
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                final Attachment newA = oldA.copy();
                newA.setIssueId(newIssue.getIssueId());
                newA.save();
                final Activity oldAct = oldA.getActivity();
                if (oldAct != null)
                {
                    final ActivitySet activitySet = newIssue.attachActivitySet(null, user);
                    ActivityManager.createTextActivity(newIssue, activitySet,
                        ActivityType.getActivityType(oldA.getActivity().getActivityType()), newA);
                }
                if (Attachment.FILE__PK.equals(newA.getTypeId()))
                {
                    try
                    {
                        oldA.copyFileTo(newA.getFullPath());
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }
        }

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CopiedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());


        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "CopiedIssueNote"));
        
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        // NOTE: There is no distinction bewteen copy and move actions in ActivitySetTypePeer.
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_COPIED,
                                getUniqueId(), newIssue.getUniqueId());
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_COPIED,
                activitySet2, newIssue, user);
        
        newIssue.index();
        
        return newIssue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void addVote(ScarabUser user)
        throws ScarabException, Exception
    {
        // check to see if the user has voted for this issue
        int previousVotes = 0;
        IssueVote issueVote = null;
        Criteria crit = new Criteria()
            .add(IssueVotePeer.ISSUE_ID, getIssueId())
            .add(IssueVotePeer.USER_ID, user.getUserId());
        List votes = IssueVotePeer.doSelect(crit);
        if (votes != null && votes.size() != 0) 
        {
            issueVote = (IssueVote)votes.get(0);
            previousVotes = issueVote.getVotes();
        }
        else 
        {
            issueVote = new IssueVote();
            issueVote.setIssueId(getIssueId());
            issueVote.setUserId(user.getUserId());
        }

        // check if the module accepts multiple votes
        if (!getModule().allowsMultipleVoting() && previousVotes > 0)
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleVoteForUnallowed,
                                      user.getUserName(), 
                                      getUniqueId());
        }
        
        // save the user's vote
        issueVote.setVotes(previousVotes+1);
        issueVote.save();

        // update the total votes for the issue
        crit = new Criteria()
            .add(AttributeValuePeer.ATTRIBUTE_ID, 
                 AttributePeer.TOTAL_VOTES__PK);
        List voteValues = getAttributeValues(crit);
        TotalVotesAttribute voteValue = null;
        if (voteValues.size() == 0) 
        {
            voteValue = new TotalVotesAttribute();
            voteValue.setIssue(this);
            voteValue.setAttributeId(AttributePeer.TOTAL_VOTES__PK);
        }
        else 
        {
            voteValue = (TotalVotesAttribute)voteValues.get(0);
        }
        // Updating attribute values requires a activitySet
        ActivitySet activitySet = attachActivitySet(null, user, null, 
           ActivitySetTypePeer.RETOTAL_ISSUE_VOTE__PK);
        voteValue.startActivitySet(activitySet);
        voteValue.addVote();
        voteValue.save();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void deleteItem(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__DELETE, module)
            || (user.getUserId().equals(getCreatedBy().getUserId()) && isTemplate()))
        {
            setDeleted(true);
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void deleteIssue(ScarabUser user)
        throws Exception, ScarabException
    {        
        if (user.hasPermission(ScarabSecurity.ISSUE__DELETE, this.getModule()))
        {
            ActivitySet activitySet = attachActivitySet(null, user);
            ActivityManager.createDeleteIssueActivity(this, activitySet);
            
            Attachment attachment = new Attachment();
            
            String note = Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "DeletedIssueNote");
            
            attachment.setData(note);
            attachment.setName(note);
            attachment.setTextFields(user, this, Attachment.MODIFICATION__PK);
            attachment.save();         
            
            this.setDeleted(true);
            List dependencies = this.getDependsRelatedByObservedId();
            dependencies.addAll(this.getDependsRelatedByObserverId());
            for (Iterator it = dependencies.iterator(); it.hasNext(); )
            {
                Depend depend = (Depend)it.next();
                if(!depend.getDeleted()){
                	ActivitySet deleteSet = 
                        this.doDeleteDependency(activitySet, depend, user);
                    for (Iterator act = deleteSet.getActivityList().iterator(); act.hasNext(); )
                    {
                        activitySet.addActivity((Activity)act.next());
                    }
                }        
            }
            
            activitySet.setAttachment(attachment);
            
            NotificationManagerFactory.getInstance()
            .addActivityNotification(ActivityType.ISSUE_DELETED,
                    activitySet, this, user);
            
            save();
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet assignUser(ActivitySet activitySet,
                                  final ScarabUser assignee, 
                                  final ScarabUser assigner,
                                  final Attribute attribute, 
                                  final Attachment attachment)
        throws TorqueException,ScarabException
    {                
        final UserAttribute attVal = new UserAttribute();

        activitySet = attachActivitySet(activitySet, assigner, attachment);
        attVal.startActivitySet(activitySet);

        ActivityManager
            .createUserActivity(this, attribute, activitySet,
                                null,
                                null, assignee.getUserId());

        // Save user attribute values
        attVal.setIssue(this);
        attVal.setAttributeId(attribute.getAttributeId());
        attVal.setUserId(assignee.getUserId());
        attVal.setValue(assignee.getUserName());
        attVal.save();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet changeUserAttributeValue(ActivitySet activitySet,
                                                final ScarabUser assignee, 
                                                final ScarabUser assigner, 
                                                final AttributeValue oldAttVal,
                                                final Attribute newAttr,
                                                final Attachment attachment)
        throws TorqueException,ScarabException
    {
        activitySet = attachActivitySet(activitySet, assigner, attachment);
        oldAttVal.startActivitySet(activitySet);

        // Save activity record for deletion of old assignment
        ActivityManager
            .createUserActivity(this, oldAttVal.getAttribute(), 
                                activitySet,
                                null,
                                assignee.getUserId(), null);


        // Save activity record for new assignment
        ActivityManager
            .createUserActivity(this, newAttr, activitySet,
                                null,
                                null, assignee.getUserId());

        // Save assignee value
        oldAttVal.setAttributeId(newAttr.getAttributeId());
        oldAttVal.save();
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet deleteUser(ActivitySet activitySet, 
            final ScarabUser assignee, 
            final ScarabUser assigner,
            final AttributeValue attVal, 
            final Attachment attachment)
        throws TorqueException, ScarabException
    {
        activitySet = attachActivitySet(activitySet, assigner, attachment);
        attVal.startActivitySet(activitySet);

        // Save activity record
        ActivityManager
            .createUserActivity(this, attVal.getAttribute(), 
                                activitySet,
                                null,
                                assignee.getUserId(), null);

        // Save assignee value
        attVal.setDeleted(true);
        attVal.save();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doDeleteDependency(ActivitySet activitySet, 
            Depend oldDepend, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final Issue otherIssue = IssueManager
                        .getInstance(oldDepend.getObserverId(), false);
        final Issue thisIssue = IssueManager
                        .getInstance(oldDepend.getObservedId(), false);

        // get the original object so that we do an update
        oldDepend = thisIssue.getDependency(otherIssue);
        oldDepend.setNew(false);
        oldDepend.setDeleted(true);
        oldDepend.save();

        // need to null out the cache entry so that Issue.getDependency()
        // does not try to return the item from the cache
        ScarabCache.put(null, thisIssue, GET_DEPENDENCY, otherIssue);

        Attachment comment = oldDepend.getDescriptionAsAttachment(user, thisIssue);

        activitySet = thisIssue.attachActivitySet(activitySet, user, comment);
        activitySet = otherIssue.attachActivitySet(activitySet, user, comment);

        ActivityManager
            .createDeleteDependencyActivity(thisIssue, activitySet, oldDepend);
        ActivityManager
            .createDeleteDependencyActivity(otherIssue, activitySet, oldDepend);


        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeUrlDescription(ActivitySet activitySet, 
                                              final ScarabUser user,
                                              final Attachment attachment, 
                                              final String oldDescription)
        throws TorqueException, ScarabException
    {
        final String newDescription = attachment.getName();
        if (!oldDescription.equals(newDescription))
        {
            final Object[] args = {
                oldDescription,
                newDescription,
            };
            String desc = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "UrlDescChangedDesc", args);

            if (desc.length() > 248)
            { 
                desc = desc.substring(0,248) + "...";
            }
            activitySet = attachActivitySet(activitySet, user);
            ActivityManager
                .createTextActivity(this, activitySet,
                                    ActivityType.URL_DESC_CHANGED, attachment,
                                    oldDescription, newDescription);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_DESC_CHANGED, activitySet, this, user);                
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeUrlUrl(ActivitySet activitySet, 
            final ScarabUser user,
            final Attachment attachment, 
            final String oldUrl)
        throws TorqueException, ScarabException
    {
        final String newUrl = attachment.getData();
        if (!oldUrl.equals(newUrl))
        {
            final Object[] args = {
                oldUrl, newUrl
            };
            String desc = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "UrlChangedDesc", args);

            if (desc.length() > 248)
            { 
                desc = desc.substring(0,248) + "...";
            }
            activitySet = attachActivitySet(activitySet, user);

            // Save activity record
            ActivityManager.createTextActivity(
                    this,
                    activitySet,
                    ActivityType.URL_CHANGED,
                    attachment,
                    oldUrl,
                    newUrl);

            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_CHANGED, activitySet, this, user);            
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeDependencyType(ActivitySet activitySet,
                                              final Depend oldDepend,
                                              final Depend newDepend, 
                                              final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldName = oldDepend.getDependType().getName();
        final String newName = newDepend.getDependType().getName();

        final boolean rolesHaveSwitched = 
            ( oldDepend.getObserverId().equals(newDepend.getObservedId()) &&
              oldDepend.getObservedId().equals(newDepend.getObserverId())
            );
        final boolean typeHasChanged = 
            ( !newName.equals(oldName));
        
        final boolean isActive = !newDepend.getDeleted();
        
        // check to see if something changed
        // only change dependency type for non-deleted deps
        if ( isActive && ( rolesHaveSwitched || typeHasChanged ) )
        {
            final Issue otherIssue = (newDepend.getObservedId().longValue() != this.getIssueId().longValue()
            		? IssueManager.getInstance(newDepend.getObservedId(), false)
            		: IssueManager.getInstance(newDepend.getObserverId(), false));

            // always delete an old dependency
            oldDepend.setDeleted(true);
            oldDepend.save();
            // always create a new dependency
            newDepend.setNew(true);
            newDepend.save();

            // need to null out the cache entry so that Issue.getDependency()
            // does not try to return the item from the cache
            ScarabCache.put(null, this, GET_DEPENDENCY, otherIssue);

            final Attachment comment = newDepend.getDescriptionAsAttachment(user, this);

            activitySet = attachActivitySet(activitySet, user, comment);
            activitySet = otherIssue.attachActivitySet(activitySet, user, comment);
            
            ActivityManager
                .createChangeDependencyActivity(this, activitySet, newDepend,
                                    oldName, newName);
            ActivityManager
                .createChangeDependencyActivity(otherIssue, activitySet, newDepend,
                                    oldName, newName);
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setInitialAttributeValues(ActivitySet activitySet, 
            Attachment attachment, 
            final HashMap newValues, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check new values for workflow
        final String msg = doCheckInitialAttributeValueWorkflow(newValues, user);
        if (msg != null)
        {
            throw new TorqueException(msg); //EXCEPTION
        }
        
        if (activitySet == null)
        {
            // Save activitySet record
            activitySet = ActivitySetManager
                .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
            activitySet.save();
        }
        setActivitySetRelatedByCreatedTransId(activitySet);

        // enter the values into the activitySet
        final LinkedMap avMap = getModuleAttributeValuesMap(); 
        final MapIterator iter = avMap.mapIterator();
        while (iter.hasNext())
        {
            final AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            try
            {
                aval.startActivitySet(activitySet);
            }
            catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
        }        
        this.save();

        // create initial issue creation activity
        ActivityManager.createReportIssueActivity(this, activitySet,  
                Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueCreated"));

        // this needs to be done after the issue is created.
        // check to make sure the attachment has data before submitting it.
        final String attachmentData = attachment.getData();
        if (attachmentData != null &&
            attachmentData.length() > 0)
        {
            attachment = AttachmentManager.getReason(attachment, this, user);
            activitySet.setAttachment(attachment);
        }
        activitySet.save();
        
        // need to clear the cache since this is after the 
        // issue is saved. for some reason, things don't
        // show up properly right away.
        ScarabCache.clear();
        
        index();
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setAttributeValues(ActivitySet activitySet,
                                          final HashMap newAttVals,
                                          final Attachment attachment,
                                          final ScarabUser user)
        throws TorqueException,ScarabException
    {
        if (!isTemplate())
        {
            final String msg = doCheckAttributeValueWorkflow(newAttVals, user);
            if (msg != null)
            {
                throw new ScarabException(L10NKeySet.ErrorExceptionMessage,msg); 
            }
        }
        if (attachment != null)
        {
            attachment.setTextFields(user, this, 
                                     Attachment.MODIFICATION__PK);
            attachment.save();
        }
        activitySet = attachActivitySet(activitySet, user, attachment );
        
        final LinkedMap avMap = getModuleAttributeValuesMap(true); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            final String newAttValValue = newAttVal.getValue();

            if (oldAttVal != null &&
            		(newAttValValue != null && !newAttValValue.equals(oldAttVal.getValue())
            		 || newAttValValue == null)
            		 )
            {
                if (newAttValValue != null && newAttValValue.length() > 0)
                {
                    oldAttVal.setProperties(newAttVal);
                }
                else
                {
                    oldAttVal.setDeleted(true);
                }
                oldAttVal.startActivitySet(activitySet);
                oldAttVal.save();
            }
        }
        index();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
       ActivitySet activitySet,
       final ScarabUser user,
       final Attachment attachment,
       final Integer activitySetType 
    )
       throws TorqueException,ScarabException
    {
        if (activitySet == null)
        {
            activitySet = getActivitySet(
               user, attachment,
               activitySetType);
            activitySet.save();
            ScarabCache.clear();
        }

        setLastTransId(activitySet.getActivitySetId());
        save();
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
        ActivitySet activitySet,
        final ScarabUser user,
        final Attachment attachment
    )
        throws TorqueException,ScarabException
    {
        return attachActivitySet(activitySet, user, attachment, ActivitySetTypePeer.EDIT_ISSUE__PK);
    }
            
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
        ActivitySet activitySet,
        final ScarabUser user
    )
        throws TorqueException,ScarabException
    {
        return attachActivitySet(activitySet, user, null, ActivitySetTypePeer.EDIT_ISSUE__PK);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public String doCheckInitialAttributeValueWorkflow(final HashMap newValues, 
                                                       final ScarabUser user)
        throws TorqueException, ScarabException
    {
        String msg = null;
        final Iterator iter = newValues.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            if (attr.isOptionAttribute())
            {
                final AttributeOption toOption = AttributeOptionManager
                     .getInstance(new Integer((String)newValues.get(attrId)));
                msg = WorkflowFactory.getInstance().checkInitialTransition(
                                                    toOption, this, 
                                                    newValues, user);
            }
            if (msg != null)
            {
                break;
            }
        }
        return msg;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public String doCheckAttributeValueWorkflow(final HashMap newAttVals, 
                                                final ScarabUser user)
        throws TorqueException,ScarabException
    {
    	final LinkedMap avMap = getModuleAttributeValuesMap(); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        String msg = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            AttributeOption fromOption = null;
            AttributeOption toOption = null;

            if (newAttVal.getValue() != null)
            {
                if (newAttVal.getAttribute().isOptionAttribute())
                {
                    if (oldAttVal.getOptionId() == null)
                    {
                        fromOption = AttributeOptionManager.getInstance(ScarabConstants.INTEGER_0);
                    }
                    else
                    {
                        fromOption = oldAttVal.getAttributeOption();
                    }
                    toOption = newAttVal.getAttributeOption();
                    msg = WorkflowFactory.getInstance().checkTransition(
                                                        fromOption, 
                                                        toOption, this, 
                                                        newAttVals, user);
                }
                if (msg != null)
                {
                    break;
                }
            }
        }
        return msg;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doEditComment(ActivitySet activitySet, 
            final String newComment, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldComment = attachment.getData();
        if (!newComment.equals(oldComment)) 
        {
            attachment.setData(newComment);
            attachment.save();
           
            activitySet = attachActivitySet( activitySet, user);
            // Save activity record
            ActivityManager
                .createTextActivity(this, null, activitySet,
                                    ActivityType.COMMENT_CHANGED, null, attachment,
                                    oldComment, newComment);
             
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.COMMENT_CHANGED, activitySet,
                    this, user);            
        }
        index();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doDeleteUrl(ActivitySet activitySet, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldUrl = attachment.getData();
        attachment.setDeleted(true);
        attachment.save();

        activitySet = attachActivitySet( activitySet, user);

        // Save activity record
        ActivityManager
            .createTextActivity(this, null, activitySet,
                                ActivityType.URL_DELETED, null, attachment, oldUrl, null);
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doRemoveAttachment(ActivitySet activitySet,
                                          final MutableBoolean physicallyDeleted,
                                          final Attachment attachment, 
                                          final ScarabUser user)
        throws TorqueException, ScarabException
    {
        boolean attachmentPhysicallyDeleted = false;
        final boolean physicalDeletionAllowed = Turbine.getConfiguration()
        .getBoolean("scarab.attachment.remove.permanent",false);

        if(physicalDeletionAllowed)
        {
            attachmentPhysicallyDeleted = attachment.deletePhysicalAttachment();
            physicallyDeleted.set(attachmentPhysicallyDeleted);
        }

        attachment.setDeleted(true);
        attachment.save();

        activitySet = attachActivitySet(activitySet, user);
        
        // Save activity record
        ActivityManager
            .createTextActivity(this, null, activitySet,
                    ActivityType.ATTACHMENT_REMOVED, null, attachment, attachment.getFileName(), null);

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isRequiredAttributeFor(Attribute attribute, ScarabUser user) throws TorqueException, ScarabException
    {
        Module module         = this.getModule();
        IssueType issueType   = this.getIssueType();
        RModuleAttribute rma  = module.getRModuleAttribute(attribute, issueType);

        boolean result = rma.getRequired();
        if(result == false)
        {
            List<Condition> conditions = rma.getConditions();
                
            Iterator<Condition> iter = conditions.iterator();
            while(iter.hasNext())
            {
                Condition condition = iter.next();
                boolean eval = condition.evaluate(user, this);
                result |= eval;
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public SkipFiltering createIssueChecker(String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        return mystate.createIssueChecker(setMarkerFunction, indent);
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public List<Activity> getActivityList() throws ScarabException
    {
        List<Activity> result = null;
/* FIXME: caching is disabled here because new Activities can be
          added to this activityset and the addition does not trigger 
          a reset of this cache (JSS).
        Object obj = ScarabCache.get(this, GET_ACTIVITY_LIST); 
        if (obj == null) 
        {
*/
            Criteria crit = new Criteria()
                .add(ActivityPeer.TRANSACTION_ID, getActivitySetId());
            try
            {
                result = ActivityPeer.doSelect(crit);
            }
            catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
//            ScarabCache.put(result, this, GET_ACTIVITY_LIST);
/*
        }
        else 
        {
            result = (List)obj;
        }
*/
        return result;
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public boolean hasTransitionSealed() throws ScarabException, TorqueException 
    {
        boolean result = false;
        String status = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if (status != null)
        {
            String value = Environment.getConfigurationProperty("scarab.common.status.sealed", null);
            if(value != null)
            {
                
                List<Activity> activities = getActivityList();
                if (activities != null)
                {
                    Iterator<Activity> iter = activities.iterator();
                    if (iter != null)
                    {
                        Activity act = null;
                        try
                        {
                            while((act = iter.next()) != null)
                            {
                                ActivityType at = ActivityType.getActivityType(act.getActivityType());
                                if(at == ActivityType.ATTRIBUTE_CHANGED)
                                {
                                    Attribute att = act.getAttribute();
                                    String name = att.getName();
                                    if(name.equals(status))
                                    {
                                       String oldv = act.getOldValue();
                                       String newv = act.getNewValue();
                                       
                                       if(value.equals(oldv) || value.equals(newv))
                                       {
                                           result = true;
                                           break;
                                       }
                                    }
                                }
                            }
                        }
                        catch (NoSuchElementException nsee)
                        {
                            Throwable th = new Throwable("No such element exception occured.(ignore and assume transitionToSealed=false)");
                            th.printStackTrace();
                            result = false;
                        }
                    }
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                        final Attribute attribute,
                                                        final IssueType issueType)
        throws TorqueException, ScarabException
    {
        return internalUser
            .getRModuleUserAttribute(module, attribute, issueType);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public String setReportingIssue(Issue issue)
        throws ScarabException
    {
        return internalUser.setReportingIssue(issue);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public String setCurrentReport(ReportBridge report)
        throws ScarabException
    {
        return internalUser.setCurrentReport(report);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setHomePage(String homePage)
        throws TorqueException, ScarabException
    {
        internalUser.setHomePage(homePage);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                       final Attribute attribute,
                                                       final IssueType issueType)
        throws TorqueException, ScarabException
    {
        RModuleUserAttribute result = null;
        final Object obj = ScarabCache.get(this, GET_R_MODULE_USERATTRIBUTE, 
                                     module, attribute, issueType); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria(4)
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId())
                .add(RModuleUserAttributePeer.LIST_ID, null);
            if (module == null) 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, 
                         module.getModuleId());
                
            }            
            if (issueType == null) 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                         issueType.getIssueTypeId());                
            }
            
            final List muas = RModuleUserAttributePeer.doSelect(crit);
            if (muas.size() == 1) 
            {
                result = (RModuleUserAttribute)muas.get(0);
            }
            else if (muas.isEmpty())
            {
                result = 
                    getNewRModuleUserAttribute(attribute, module, issueType);
            }
            else 
            {
                throw new ScarabException(L10NKeySet.ExceptionMultipleJDMs);
            }
            ScarabCache.put(result, this, GET_R_MODULE_USERATTRIBUTE, 
                            module, attribute, issueType);
        }
        else 
        {
            result = (RModuleUserAttribute)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public String setReportingIssue(Issue issue)
        throws ScarabException
    {
        String key = null;
        if (issue == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNullIssueForbidden);
        }
        else 
        {
            key = String.valueOf(issueCount++);
            setReportingIssue(key, issue);
        }
        return key;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public String setCurrentReport(ReportBridge report)
        throws ScarabException
    {
        String key = null;
        if (report == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNullReportForbidden);
        }
        else 
        {
            key = String.valueOf(reportCount++);
            setCurrentReport(key, report);
        }
        return key;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void setHomePage(final String homePage)
        throws TorqueException, ScarabException
    {
        if ("ModuleNotReady.vm".equals(homePage)) 
        {
            throw new ScarabException(L10NKeySet.ExceptionForbiddenHomeModuleNotReady);
        }
        final UserPreference up = UserPreferenceManager.getInstance(getUserId());
        up.setHomePage(homePage);
        up.save();
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public boolean deletePhysicalAttachment() 
	throws TorqueException, ScarabException
    {
        File f = new File(getFullPath());
        return f.delete();
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public String getRelativePath()
        throws TorqueException,ScarabException
    {
        if (isNew()) 
        {
            throw new ScarabException(L10NKeySet.ExceptionPathNotSet);
        }        
        String path = null;
        String filename = getFileName();
        if (filename != null) 
        {
            // moduleId/(issue_IdCount/1000)/issueID_attID_filename
            StringBuffer sb = new StringBuffer(30 + filename.length());
            final Issue issue = getIssue();
            sb.append("mod").append(issue.getModule().getQueryKey())
                .append(File.separator)
                .append(issue.getIdCount() / 1000)
                .append(File.separator)
                .append(issue.getUniqueId()).append('_')
                .append(getQueryKey()).append('_')
                .append(filename);
            path = sb.toString();
        }
        return path;
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public String getFullPath()
        throws TorqueException,ScarabException
    {
        String path = null;
        final String relativePath = getRelativePath();
        if (relativePath != null) 
        {
            path = getRepositoryDirectory() + File.separator + relativePath;
        }
        return path;
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public void copyFileTo(final String path)
        throws TorqueException, ScarabException, FileNotFoundException, IOException
    {
        copyFileFromTo(getFullPath(), path);
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public long getSize()
    	throws TorqueException, ScarabException
    {
        if (size== -1) {
        	Log.get(this.getClass().getName()).debug("getSize() reading attachment size from FileSystem");
	        final String path = getFullPath();
	        if (path != null) {
		        final File f = new File(getFullPath());
		        if (f!= null  && f.exists()) {
		            size = f.length();  
	            }
	        }
        } else {
        	Log.get(this.getClass().getName()).debug("getSize() reading attachment size from cache");
        }
        return size;
    }
            
// in java/org/tigris/scarab/om/ReportPeer.java
public static boolean exists(final String name)
        throws TorqueException, ScarabException
    {
        return retrieveByName(name) != null;
    }
            
// in java/org/tigris/scarab/om/ReportPeer.java
public static Report retrieveByName(final String name)
        throws TorqueException, ScarabException
    {
        Report report = null;
        final Criteria crit = new Criteria()
            .add(NAME, name)
            .add(DELETED, false);
        final List reports = doSelect(crit);
        if (reports.size() == 1) 
        {
            report = (Report)reports.get(0);
        }
        else if (reports.size() > 1) 
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleReports,
                                      name);
        }
        
        return report;
    }
            
// in java/org/tigris/scarab/om/AttributeType.java
public static AttributeType getInstance(final String attributeTypeName) 
        throws TorqueException, ScarabException
    {
        AttributeType result = null;
        final Object obj = ScarabCache.get(ATTRIBUTETYPE, GET_INSTANCE, 
                                     attributeTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(AttributeTypePeer.ATTRIBUTE_TYPE_NAME, attributeTypeName);
            final List attributeTypes = AttributeTypePeer.doSelect(crit);
            if(attributeTypes.size() > 1)
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateAttributeTypeName,
                                          attributeTypeName);
            }
            result = (AttributeType)attributeTypes.get(0);
            ScarabCache.put(result, ATTRIBUTETYPE, GET_INSTANCE, 
                            attributeTypeName);
        }
        else 
        {
            result = (AttributeType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Depend.java
public void setObserverUniqueId(String uniqueId)
         throws TorqueException, ScarabException
    {
        if (getDefaultModule() == null)
        {
            throw new ScarabException( L10NKeySet.ExceptionDependInternalWorkflow,
                                       "setDefaultModule()",
                                       "setObserverUniqueId()");
        }
        Issue childIssue = IssueManager.getIssueById(uniqueId.trim());
        if (childIssue == null)
        {
           String code = getDefaultModule().getCode();
           uniqueId = code + uniqueId;
           childIssue = IssueManager.getIssueById(uniqueId);
        }
        super.setObserverId(childIssue.getIssueId());
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped template, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        boolean success = true;
        final Issue issue = IssueManager.getInstance(getIssueId());

        // If it's a module template, user must have Item | Approve 
        //   permission, or its Approved field gets set to false
        if (getScopeId().equals(Scope.PERSONAL__PK)
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        } 
        else
        {
            setApproved(false);
            issue.save();

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");
                
                ScarabUser[] toUsers = module.getUsers(ScarabSecurity.MODULE__EDIT);
                // if the module doesn't have any users, then we need to add at 
                // least ourselves...
                if (toUsers.length == 0)
                {
                    toUsers = new ScarabUser[1];
                    toUsers[0] = user;
                }

                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewTemplateRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx, 
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null, template);
                }
                catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            }
        }
        save();
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getIssue().getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void delete(final ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        final IssueType issueType = getIssueType();

        if (user.hasPermission(ScarabSecurity.MODULE__CONFIGURE, module))
        {
            // Delete both active and inactive attribute groups first
            final List attGroups = issueType.getAttributeGroups(module, false);
            for (int j=0; j<attGroups.size(); j++)
            {
                // delete attribute-attribute group map
                final AttributeGroup attGroup = 
                              (AttributeGroup)attGroups.get(j);
                attGroup.delete();
            }

            // Delete mappings with user attributes
            List rmas = module.getRModuleAttributes(issueType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
            // Delete mappings with user attributes for template type
            final IssueType templateType = issueType.getTemplateIssueType();
            rmas = module.getRModuleAttributes(templateType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
 
            // delete workflows
            WorkflowFactory.getInstance().resetAllWorkflowsForIssueType(module, 
                                                                        issueType);
            // delete templates
            Criteria c = new Criteria()
                .add(IssuePeer.TYPE_ID, templateType.getIssueTypeId());
            final List result = IssuePeer.doSelect(c);
            final List issueIdList = new ArrayList(result.size());
            for (int i=0; i < result.size(); i++) 
            {
                final Issue issue = (Issue)result.get(i);
                issueIdList.add(issue.getIssueId());
            }
            IssuePeer.doDelete(c);
            if (!issueIdList.isEmpty())
            {
                c = new Criteria()
                    .addIn(IssueTemplateInfoPeer.ISSUE_ID, issueIdList);
                IssueTemplateInfoPeer.doDelete(c);
            }
            
            // mit list items
            c = new Criteria()
                .add(MITListItemPeer.MODULE_ID, module.getModuleId())
                .add(MITListItemPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
            final List listItems = MITListItemPeer.doSelect(c);
            final List listIds = new ArrayList(listItems.size());

            for (int i=0; i < listItems.size(); i++) 
            {
                final MITList list = ((MITListItem)listItems.get(i)).getMITList();
                final Long listId = list.getListId();
                if (list.isSingleModuleIssueType() && !listIds.contains(listId))
                {
                    listIds.add(listId);
                }
            }
            MITListItemPeer.doDelete(c);

            if (!listIds.isEmpty())
            {
                // delete single module-issuetype mit lists
                c = new Criteria()
                    .addIn(MITListPeer.LIST_ID, listIds);
                MITListPeer.doDelete(c);

                // delete queries
                c = new Criteria()
                    .addIn(QueryPeer.LIST_ID, listIds);
                QueryPeer.doDelete(c);
            }

            c = new Criteria()
                .add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .add(RModuleIssueTypePeer.ISSUE_TYPE_ID, getIssueTypeId());
            RModuleIssueTypePeer.doDelete(c);
            RModuleIssueTypeManager.removeFromCache(this);
            final List rmits = module.getRModuleIssueTypes();
            rmits.remove(this);
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void delete()
         throws TorqueException, ScarabException
    {                
        int dupeSequence = 0;
        final Integer issueTypeId = getIssueTypeId();
        final IssueType issueType = IssueTypeManager
            .getInstance(SimpleKey.keyFor(issueTypeId), false);
        List attrGroups = null;

        if (isGlobal())
        {
            attrGroups = issueType.getAttributeGroups(null, false);
            dupeSequence =  issueType.getDedupeSequence();
            // Delete issuetype-attribute mapping
            final Criteria crit  = new Criteria()
                .addJoin(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                         RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                .add(RAttributeAttributeGroupPeer.GROUP_ID,
                     getAttributeGroupId())
                .add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, issueTypeId);
            final List results = RIssueTypeAttributePeer.doSelect(crit);
            for (Iterator i = results.iterator(); i.hasNext();)
            {
                ((RIssueTypeAttribute)i.next()).delete();
            }
        }
        else
        {
            if (issueType.getLocked())
            { 
                
                throw new ScarabException(L10NKeySet.ExceptionGroupDeleteForbidden,
                          this.getName(),
                          issueType.getName());
            }            
            else
            {
                final Module module = getModule();
                attrGroups = getIssueType().getAttributeGroups(module, false);
                dupeSequence =  module.getDedupeSequence(issueType);
                // Delete module-attribute mapping
                final Criteria crit  = new Criteria()
                    .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                             RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                    .add(RAttributeAttributeGroupPeer.GROUP_ID,
                             getAttributeGroupId())
                    .add(RModuleAttributePeer.MODULE_ID,
                         getModuleId());
                final Criteria.Criterion critIssueType = crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                getIssueTypeId(), Criteria.EQUAL);
                critIssueType.or(crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                issueType.getTemplateId(), Criteria.EQUAL));
                crit.and(critIssueType);
                final List results = RModuleAttributePeer.doSelect(crit);
                for (int i=0; i<results.size(); i++)
                {
                    final RModuleAttribute rma = (RModuleAttribute)results.get(i);
                    rma.delete();
                }
            }
        }

        // Delete attribute - attribute group mapping
        Criteria crit2 = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, getAttributeGroupId());
        RAttributeAttributeGroupPeer.doDelete(crit2);


        // Delete the attribute group
        final int order = getOrder();
        crit2 = new Criteria()
            .add(AttributeGroupPeer.ATTRIBUTE_GROUP_ID, getAttributeGroupId());
        AttributeGroupPeer.doDelete(crit2);
        IssueTypeManager.getManager().refreshedObject(this);
            
        // Adjust the orders for the other attribute groups
        for (int i=0; i<attrGroups.size(); i++)
        {
            final AttributeGroup tempGroup = (AttributeGroup)attrGroups.get(i);
            int tempOrder = tempGroup.getOrder();
            if (tempGroup.getOrder() > order)
            {
                if (tempOrder == dupeSequence + 1 && tempOrder == 3)
                {
                    tempGroup.setOrder(tempOrder - 2);
                }
                else
                {
                    tempGroup.setOrder(tempOrder - 1);
                }
                tempGroup.save();
            }
        } 
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void addAttribute(final Attribute attribute)
         throws TorqueException, ScarabException
    {                
        final IssueType issueType = getIssueType();
        final Module module = getModule();

        // add attribute group-attribute mapping
        final RAttributeAttributeGroup raag =
            addRAttributeAttributeGroup(attribute);
        raag.save();
        if (Log.get().isDebugEnabled()) 
        {
            Log.get().debug("Calling getAttributes() from addAttribute in order to add attribute id="
                            + attribute.getAttributeId() + " to the List");
        }
        // FIXME! Distributed cache buster, cache should be invalidated.
        final List attributes = getAttributes();
        if (!attributes.contains(attribute)) 
        {
            attributes.add(attribute);
        }
        
        final List allOptions = attribute.getAttributeOptions(false);
        // remove duplicate options
        // FIXME! why would we ever want Attribute.getAttributeOptions to
        // return dupes, should this code be in that method?
        final ArrayList options = new ArrayList();
        for (int i=0; i<allOptions.size(); i++)
        {
            final AttributeOption option = (AttributeOption)allOptions.get(i);
            if (!options.contains(option))
            {
                options.add(option);
            }
        }

        if (isGlobal())
        {
            // this is a global attribute group
            // add issuetype-attribute groupings
            issueType.addRIssueTypeAttribute(attribute);

            // add issueType-attributeoption mappings
            for (int j=0;j < options.size();j++)
            {
                final AttributeOption option = (AttributeOption)options.get(j);
                final List roos = option.getROptionOptionsRelatedByOption2Id();
                final ROptionOption roo = (ROptionOption)roos.get(0);
                final RIssueTypeOption rio = new RIssueTypeOption();
                rio.setIssueTypeId(issueType.getIssueTypeId());
                rio.setOptionId(option.getOptionId());
                rio.setOrder(roo.getPreferredOrder());
                rio.setWeight(roo.getWeight());
                // making sure error is recorded in same log as our other
                // debugging for pcn 17683.
                try 
                {
                    rio.save();                    
                }
                catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
            }
        }
        else
        {
            // add module-attribute groupings
            module.addRModuleAttribute(issueType, attribute);

            // add module-attributeoption mappings
            for (int j=0;j < options.size();j++)
            {
                final AttributeOption option = (AttributeOption)options.get(j);
                final List roos = option.getROptionOptionsRelatedByOption2Id();
                final ROptionOption roo = (ROptionOption)roos.get(0);
                final RModuleOption rmo = new RModuleOption();
                rmo.setModuleId(getModuleId());
                rmo.setIssueTypeId(issueType.getIssueTypeId());
                rmo.setOptionId(option.getOptionId());
                rmo.setDisplayValue(option.getName());
                rmo.setOrder(roo.getPreferredOrder());
                rmo.setWeight(roo.getWeight());
                rmo.save();

                // add module-attributeoption mappings to template type
                final IssueType templateType = IssueTypeManager
                    .getInstance(issueType.getTemplateId(), false);
                final RModuleOption rmo2 = module.
                     addRModuleOption(templateType, option);
                rmo2.save();
            }
        }
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void deleteAttribute(final Attribute attribute, 
            final ScarabUser user,
            final Module module)
         throws TorqueException, ScarabException
    {                
        String permission = null;
        if (isGlobal())
        {
            permission = (ScarabSecurity.DOMAIN__EDIT);
        }
        else
        {
            permission = (ScarabSecurity.MODULE__CONFIGURE);
        }
        if (user.hasPermission(permission, module))
        {
            final IssueType issueType = getIssueType();
            final IssueType template = IssueTypeManager.getInstance
                                 (issueType.getTemplateId());
            boolean success = true;

            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
            if (isGlobal())
            {
                // This is a global attribute group
                // Remove attribute - issue type mapping
                final List rias = issueType.getRIssueTypeAttributes
                                     (false, AttributePeer.NON_USER);
                if (ria != null) 
                {
                    ria.delete();                    
                }
                if (rias != null) 
                {
                    rias.remove(ria);        
                }
            }
            else
            {
                // Check if attribute is locked
                if (ria != null && ria.getLocked())
                {
                    success = false;
                    throw new TorqueException(attribute.getName() + "is locked"); //EXCEPTION
                }
                else
                {
                    // Remove attribute - module mapping
                    final List rmas = module.getRModuleAttributes(issueType, false,
                                                            AttributePeer.NON_USER);    
                    final RModuleAttribute rma = module
                        .getRModuleAttribute(attribute, issueType);
                    if(rma != null)rma.delete();
                    WorkflowFactory.getInstance().deleteWorkflowsForAttribute
                                                  (attribute, module, issueType);
                    if(rma != null)rmas.remove(rma);

                    // Remove attribute - module mapping from template type
                    final RModuleAttribute rma2 = module
                                   .getRModuleAttribute(attribute, template);
                    if(rma2 != null)
                    {
                        rma2.delete();
                        rmas.remove(rma2);
                    }
                }
            }

            if (success)
            {
                // Remove attribute - group mapping
                final RAttributeAttributeGroup raag = 
                    getRAttributeAttributeGroup(attribute);
                raag.delete();

                if (attribute.isOptionAttribute())
                {
                    if (isGlobal())
                    { 
                        // global attributeGroup; remove issuetype-option maps
                        final List rios = issueType.getRIssueTypeOptions(attribute);
                        if (rios != null)
                        {
                            for (int i = 0; i<rios.size();i++)
                            {
                                ((RIssueTypeOption) rios.get(i))
                                    .delete(user, module);
                            }
                        }
                    }
                    else
                    {
                        // Remove module-option mapping
                        final List rmos = module.getRModuleOptions(attribute, issueType);
                        if (rmos != null)
                        {
                            rmos.addAll(module.getRModuleOptions(attribute, template));
                            for (int j = 0; j<rmos.size();j++)
                            {
                                final RModuleOption rmo = (RModuleOption)rmos.get(j);
                                 // rmo's may be inherited by the parent module.
                                 // don't delete unless they are directly associated
                                 // with this module.  Will know by the first one.
                                 if (rmo.getModuleId().equals(module.getModuleId())) 
                                 {
                                     rmo.delete();
                                 }
                                 else 
                                 {
                                     break;
                                 } 
                             }
                         }
                     }
                 }
             }
         }
         else
         {
             throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
         }            
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
            
// in java/org/tigris/scarab/om/AttachmentType.java
public static AttachmentType getInstance(String attachmentTypeName)
        throws TorqueException,ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(BaseAttachmentTypePeer.ATTACHMENT_TYPE_NAME, attachmentTypeName);
        List attachmentTypes = AttachmentTypePeer.doSelect(crit);
        if(attachmentTypes.size() > 1)
        {
            throw new ScarabException(L10NKeySet.ExceptionAttachmentDuplicateTypename);
        }
        return (AttachmentType)attachmentTypes.get(0);
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getTemplates(Module module, IssueType issueType,
                                    ScarabUser user, String sortColumn, 
                                    String sortPolarity, String type)
        throws TorqueException, ScarabException
    {
        List templates = null;
        Serializable[] key = {TEMPLATE_PEER, GET_TEMPLATES, module,
            issueType, user, sortColumn, sortPolarity, type};
        Object obj = ScarabCache.get(key);
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(IssuePeer.MODULE_ID, module.getModuleId())
                .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MOVED, 0)
                .addJoin(ActivitySetPeer.TRANSACTION_ID, 
                         ActivityPeer.TRANSACTION_ID) 
                .addJoin(IssuePeer.ISSUE_ID, 
                         ActivityPeer.ISSUE_ID) 
                .add(IssuePeer.TYPE_ID, issueType.getTemplateId())
                .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID);
            crit.setDistinct();

            Criteria.Criterion cGlob = crit.getNewCriterion(
                IssueTemplateInfoPeer.SCOPE_ID, Scope.MODULE__PK,
                Criteria.EQUAL);
            cGlob.and(crit.getNewCriterion(IssueTemplateInfoPeer.APPROVED, 
                                           Boolean.TRUE, Criteria.EQUAL));
            Criteria.Criterion cPriv = crit.getNewCriterion(
                ActivitySetPeer.CREATED_BY, user.getUserId(),  
                Criteria.EQUAL);
            cPriv.and(crit.getNewCriterion(
                IssueTemplateInfoPeer.SCOPE_ID, Scope.PERSONAL__PK, 
                Criteria.EQUAL));

            if (TYPE_PRIVATE.equals(type))
            {
                crit.add(cPriv);
            }
            else if (TYPE_GLOBAL.equals(type))
            {
                crit.add(cGlob);
            }
            else
            {
                // All templates
                cGlob.or(cPriv);
                crit.add(cGlob);
            }

            // Add sort criteria
            if (sortColumn.equals("desc"))
            {
                addSortOrder(crit, IssueTemplateInfoPeer.DESCRIPTION, 
                             sortPolarity);
            }
            else if (sortColumn.equals("avail"))
            {
                crit.addJoin(IssueTemplateInfoPeer.SCOPE_ID,
                             ScopePeer.SCOPE_ID);
                addSortOrder(crit, ScopePeer.SCOPE_NAME, sortPolarity);
            }
            else if (!sortColumn.equals("user"))
            {
                // sort by name
                addSortOrder(crit, IssueTemplateInfoPeer.NAME, sortPolarity);
            }
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, key);
        }
        else 
        {
            templates = (List)obj;
        }
        if (sortColumn.equals("user"))
        {
            templates = sortByCreatingUser(templates, sortPolarity);
        }
        return templates;
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getUserTemplates(ScarabUser user, Module module,IssueType issueType)
        throws TorqueException, ScarabException
    {
        List templates = null;
        Object obj = ScarabCache.get(TEMPLATE_PEER, GET_USER_TEMPLATES, user);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
            .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID)
            .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MODULE_ID, module.getModuleId())
            .addJoin(ActivitySetPeer.TRANSACTION_ID, 
                     ActivityPeer.TRANSACTION_ID) 
                .addJoin(IssuePeer.ISSUE_ID, 
                         ActivityPeer.ISSUE_ID) 
            .add(IssuePeer.TYPE_ID, issueType.getTemplateId())
            .add(ActivitySetPeer.CREATED_BY, user.getUserId());
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, TEMPLATE_PEER, GET_USER_TEMPLATES, user);
        }
        else 
        {
            templates = (List)obj;
        }
        return templates;
    }
            
// in java/org/tigris/scarab/xmlrpc/NewTicketHandler.java
public String createNewTicket( String moduleCode, 
								   String issueTypeName, 
								   String userName, 
								   Hashtable attribs) throws TorqueException, ScarabException {
		
		//init environment for the new issue
		Module module = ModuleManager.getInstance(null, null, moduleCode);
		IssueType issueType = IssueType.getInstance(issueTypeName);
		Issue issue = module.getNewIssue(issueType);
		ScarabUser user = ScarabUserManager.getInstance(userName);
        
        Attachment reason = new Attachment();
        reason.setData("Created by xmlrpc");
        reason.setName("reason");
        
        //init issue, set and store attributes
		ActivitySet activitySet = null;
        activitySet = issue.setInitialAttributeValues(activitySet, reason, new HashMap(), user);

        // Save any unsaved attachments as part of this ActivitySet as well.
        setAttributes(issue,activitySet,reason,user,attribs);
        activitySet = issue.doSaveFileAttachments(activitySet, user);
        activitySet.save();
        
        return issue.getUniqueId();
	}
            
// in java/org/tigris/scarab/xmlrpc/NewTicketHandler.java
private void setAttributes(Issue issue, ActivitySet activitySet, Attachment attachment, ScarabUser user, Hashtable attribs) throws TorqueException, ScarabException {

        LinkedMap avMap = issue.getModuleAttributeValuesMap(false); 
        HashMap newValues = new HashMap();
        
        for (MapIterator i = avMap.mapIterator();i.hasNext();) 
        {
            AttributeValue aval = (AttributeValue)avMap.get(i.next());
        	String key = aval.getAttribute().getName();
        	String newValue = (String)attribs.get(key);
        	
        	if (newValue != null) {
        		AttributeValue newVal = aval.copy();
        		newVal.setValue(newValue);
				newValues.put(aval.getAttributeId(),newVal);
        	}
        }
        issue.setAttributeValues(activitySet, newValues, attachment, user);
	}
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public boolean canMakeTransitionsFrom(ScarabUser user,
    		IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption) throws ScarabException
    {
    	Module module = user.getCurrentModule();
        boolean result = false;
        List availableOptions = getAvailableOptions(issueType, attribute, module);		
        List allTransitions = TransitionPeer.getTransitionsFrom(availableOptions, attribute, fromOption);
        Iterator iter = allTransitions.iterator();
        if(!iter.hasNext())
        {
        	return true; // no transition rules available -> any transition possible
        }
        
        while (!result && iter.hasNext())
        {
            Object obj = iter.next();
            Transition tran = (Transition) obj;

			if(transitionIsSupportedByOptions(tran, availableOptions))
			{
                Role requiredRole = tran.getRole();
                if (requiredRole != null)
                { 	// A role is required for this transition to be
                	// allowed
                	result = user.hasRoleInModule(requiredRole, module);
                }
                else
                {
                    result = true;
                }
			}
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public List getTransitions(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        Module module = user.getCurrentModule();
        List result = null;
        List availableOptions = getAvailableOptions(issueType, attribute, module);

        Iterator optionsIter = availableOptions.iterator();
        while(optionsIter.hasNext())
        {
            RModuleOption rmoduleOption = (RModuleOption)optionsIter.next();
            AttributeOption fromOption;
            try
            {
                fromOption = rmoduleOption.getAttributeOption();
            }
            catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            List list = getTransitionsFrom(user,issueType,attribute,fromOption);
            if(list != null)
            {
                if(result == null)
                {
                    result = list;
                }
                else
                {
                    result.addAll(list);
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public TransitionNode getTransitionTree(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        Module module = user.getCurrentModule();
        TransitionNode result = null;
        List availableOptions = getAvailableOptions(issueType, attribute, module,false);
        List visitedTransitions = null;
        Iterator optionsIter = availableOptions.iterator();
        while(optionsIter.hasNext())
        {
            RModuleOption rmoduleOption = (RModuleOption)optionsIter.next();
            AttributeOption fromOption;
            try
            {
                fromOption = rmoduleOption.getAttributeOption();
            }
            catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            List list = getTransitionsFrom(user,issueType,attribute,fromOption,false);
            if(list != null)
            {
                if(result == null)
                {
                    result = new TransitionNode(fromOption);
                }
                for(int index=0; index < list.size(); index++)
                {
                    Transition t = (Transition)list.get(index);
                    if(visitedTransitions == null)
                    {
                        visitedTransitions = new ArrayList();
                    }
                    if(visitedTransitions.contains(t))
                    {
                        continue;
                    }
                    visitedTransitions.add(t);
                    TransitionNode child = result.addNode(t);
                    getTransitionTree(user, issueType, attribute, t.getTo(), child, visitedTransitions);
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public void getTransitionTree(ScarabUser user,
            IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption,
            TransitionNode node,
            List visitedTransitions) throws ScarabException
    {
        List list = getTransitionsFrom(user,issueType,attribute,fromOption,false);
        if(list != null)
        {
            for(int index=0; index < list.size(); index++)
            {
                Transition t = (Transition)list.get(index);
                if(visitedTransitions.contains(t))
                {
                    continue;
                }
                visitedTransitions.add(t);
                TransitionNode child = node.addNode(t);
                AttributeOption toOption = t.getTo();
                TransitionNode parent = node.getParent();
                while(parent != null && !parent.getOption().equals(toOption))
                {
                    parent = parent.getParent();
                }
                if(parent == null)
                {
                    getTransitionTree(user,issueType,attribute,t.getTo(),child,visitedTransitions);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private List getAvailableOptions(IssueType issueType, Attribute attribute, Module module) throws ScarabException
    {
        return getAvailableOptions(issueType, attribute, module, true);
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private List getAvailableOptions(IssueType issueType, Attribute attribute, Module module, boolean activeOnly) throws ScarabException
    {
        List availableOptions;
        try 
        {
            availableOptions = module.getOptionTree(attribute,issueType,activeOnly);
        } catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
        return availableOptions;
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public List getTransitionsFrom(ScarabUser user,
            IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption) throws ScarabException
    {
        return getTransitionsFrom(user, issueType, attribute, fromOption, false);
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private List getTransitionsFrom(ScarabUser user,
                                   IssueType issueType,
                                   Attribute attribute,
                                   AttributeOption fromOption,
                                   boolean activeOnly) throws ScarabException
                           {
        Module module = user.getCurrentModule();
        List result;
        List availableOptions = getAvailableOptions(issueType, attribute, module, activeOnly);
        List allTransitions = TransitionPeer.getTransitionsFrom(availableOptions, attribute, fromOption);
        Iterator iter = allTransitions.iterator();
        if(iter.hasNext())
        {
            result = new ArrayList();
            while (iter.hasNext())
            {
                Object obj = iter.next();
                Transition transition = (Transition) obj;

                boolean isSupportedByOptions = transitionIsSupportedByOptions(transition, availableOptions);
                if (isSupportedByOptions || !activeOnly)
                {
                    boolean addTransition;
                    
                    if(activeOnly)
                    {
                        Role requiredRole = transition.getRole();
                        if (requiredRole != null)
                        {
                            // A role is required for this transition to be allowed
                            addTransition = user.hasRoleInModule(
                                    requiredRole, module);
                        }
                        else
                        {
                            addTransition = true;
                        }
                    }
                    else
                    {
                        addTransition = true;
                    }

                    if (addTransition)
                    {
                        result.add(transition);
                    }
                }
            }
        }
        else
        {
            result = null; // no transitions defined -> all transitions allowed
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public boolean canMakeTransition(ScarabUser user,
                                     AttributeOption fromOption, 
                                     AttributeOption toOption,
                                     Issue issue)
        throws ScarabException

    {
        return true;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public List getTransitions(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public TransitionNode getTransitionTree(ScarabUser user,
            IssueType issueType,
            Attribute attribute) throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public List getTransitionsFrom(ScarabUser user,
            IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption) throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public boolean canMakeTransitionsFrom(ScarabUser user,
    		IssueType issueType,
            Attribute attribute,
            AttributeOption fromOption)
    throws ScarabException
    {
    	return true;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public String checkTransition(AttributeOption fromOption, 
                                  AttributeOption toOption,
                                  Issue issue, Map newAttVals,
                                  ScarabUser user)
        throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public String checkInitialTransition(AttributeOption toOption,
                                         Issue issue, Map newAttVals,
                                         ScarabUser user)
        throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public OptionWorkflow getWorkflowForRole(AttributeOption fromOption, 
                                             AttributeOption toOption,
                                             String roleName,
                                             Module module,
                                             IssueType issueType)
        throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public List getWorkflowsForIssueType(IssueType issueType)
        throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public List getWorkflowsForRoleList(AttributeOption fromOption, 
                                        AttributeOption toOption,
                                        List roleNames, 
                                        Module module,
                                        IssueType issueType)
        throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public OptionWorkflow inherit(AttributeOption fromOption, 
                                   AttributeOption toOption,
                                   String roleName, Module module,
                                   IssueType issueType)
        throws ScarabException
    {
        return null;
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void saveWorkflow(AttributeOption fromOption, 
                             AttributeOption toOption,
                             String roleName, Module module,
                             IssueType issueType, WorkflowRules workflowRule)
        throws ScarabException
    {
        //nothing
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void resetWorkflow(AttributeOption fromOption, 
                              AttributeOption toOption,
                              String roleName, Module module,
                              IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void resetWorkflows(String roleName, Module module, IssueType issueType,
                               boolean initial)
        throws ScarabException
    {
       // nothing
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void deleteWorkflowsForOption(AttributeOption option,
                                         Module module, IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void deleteWorkflowsForAttribute(Attribute attr, Module module, 
                                            IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void addIssueTypeWorkflowToModule(Module module, 
                                            IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void copyIssueTypeWorkflows(IssueType issueType, IssueType newIssueType)
        throws ScarabException
    {
       // nothing
    }
            
// in java/org/tigris/scarab/workflow/DefaultWorkflow.java
public void resetAllWorkflowsForIssueType(Module module, 
                                              IssueType issueType)
        throws ScarabException
    {
       // nothing
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public  SkipFiltering createIssueChecker(String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        String result = "";
        List<Attribute> attributes = null;
        Module module = issue.getModule();
        IssueType issueType = issue.getIssueType();
        attributes = issueType.getActiveAttributes(module);
        Iterator<Attribute> iter = attributes.iterator();
        while (iter.hasNext())
        {
            Attribute attribute = iter.next();
            RModuleAttribute rma  = module.getRModuleAttribute(attribute, issueType);
            result += createIssueChecker(rma, setMarkerFunction, indent);
        }
        
        String prepend;
        if(result.length() > 0)
        {
            prepend="\n";
        }
        else
        {
            prepend = "/* No conditional attributes found for this module/issueType */";
        }
        
        return new SimpleSkipFiltering(prepend+result);
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
private String createIssueChecker(RModuleAttribute rma, String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        String result = "";
        boolean isRequired = rma.getRequired();
        if(!isRequired)
        {
            List<Condition> conditions = rma.getConditions();
                
            Iterator<Condition> iter = conditions.iterator();
            while(iter.hasNext())
            {
                Condition condition = iter.next();
                result += condition.createConditionCheckerScript(rma, setMarkerFunction, indent);
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/WorkflowFactory.java
public static Workflow getInstance() throws ScarabException
    {
        Workflow wf = null;
        String className = null;
        try
        {
            if (getForceUseDefault())
            {
                wf = (Workflow) DefaultWorkflow.class.newInstance();
            }
            else
            {
                List classNames = Turbine.getConfiguration()
                    .getList("scarab.workflow.classname");
                if (classNames.size() > 0)
                {
                    className = (String) classNames.get(0);
                }
    
                Class wfClass = (className != null ? Class.forName(className) :
                                 DefaultWorkflow.class);
                wf = (Workflow) wfClass.newInstance();
            }
        }
        catch (InstantiationException ie)
        {
            throw new ScarabException(L10NKeySet.ExceptionInstantiation, className, ie);
        }
        catch (IllegalAccessException iae)
        {
            throw new ScarabException(L10NKeySet.ExceptionIllegalAccess, className, iae);
        }
        catch (ClassNotFoundException cnfe)
        {
            throw new ScarabException(L10NKeySet.ExceptionClassNotFound, className, cnfe);
        }
        return wf;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
void doHandleDependencies()
        throws ScarabException, TorqueException
    {
        LOG.debug("Number of dependencies found: " + allDependencies.size());
        for (Iterator itr = allDependencies.iterator(); itr.hasNext();)
        {
            final Object[] data = (Object[])itr.next();
            final ActivitySet activitySetOM = (ActivitySet) data[0];
            final XmlActivity activity = (XmlActivity) data[1];
            

            final Dependency dependency = activity.getDependency();
            final String child = (String)issueXMLMap.get(dependency.getChild());
            final String parent = (String)issueXMLMap.get(dependency.getParent());
            if (parent == null || child == null)
            {
                if(null != parent || null != child)
                {
                    // add a comment into the issue that informs of the dependency
                    final Issue issueOM = IssueManager.getIssueById(null == parent ? child : parent);
                    final Attachment attachmentOM = new Attachment();
                    attachmentOM.setName("comment");
                    attachmentOM.setTypeId(Attachment.COMMENT__PK);
                    attachmentOM.setMimeType("text/plain");
                    // TODO i18n this
                    final String text = "Dependency \"" 
                            + parent + " (originally " + dependency.getParent() + ") " + dependency.getType() + ' ' 
                            + child + " (originally " + dependency.getParent()
                        + ") \" was not imported due to " 
                        + (null == parent ? dependency.getParent() : dependency.getChild()) + " not being resolved";
                    attachmentOM.setData(text);                    
                    issueOM.addComment(attachmentOM, ScarabUserManager.getInstance("Administrator"));
                }
                
                LOG.debug("Could not find issues: parent: " + parent + " child: " + child);
                LOG.debug("----------------------------------------------------");
                continue;
            }
            LOG.debug("doHandleDependencies: " + dependency);
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                LOG.error("[TODO] update-same-db import type not yet implemented");
                // trick here is that dependencies don't have ids or unique keys to find the 
                //  correct existing instance against.
            }
            else
            {
                try
                {
                    final String type = dependency.getType();
                    final Depend newDependOM = DependManager.getInstance();
                    final Issue parentIssueOM = IssueManager.getIssueById(parent);
                    final Issue childIssueOM = IssueManager.getIssueById(child);
                    newDependOM.setDefaultModule(parentIssueOM.getModule());
                    newDependOM.setObservedId(parentIssueOM.getIssueId());
                    newDependOM.setObserverId(childIssueOM.getIssueId());
                    newDependOM.setDependType(type);
                    LOG.debug("Dep: " + type + " Parent: " + parent + " Child: " + child);
                    LOG.debug("XML Activity id: " + activity.getId());
                    if (activity.isAddDependency())
                    {
                        parentIssueOM
                          .doAddDependency(activitySetOM, newDependOM, childIssueOM, null);
                        LOG.debug("Added Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isDeleteDependency())
                    {
                        parentIssueOM
                          .doDeleteDependency(activitySetOM, newDependOM, null);
                        LOG.debug("Deleted Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isUpdateDependency())
                    {
                        final Depend oldDependOM = parentIssueOM.getDependency(childIssueOM);
                        if (oldDependOM == null)
                        {
                            throw new IllegalArgumentException ("Whoops! Could not find the original dependency!"); //EXCEPTION
                        }
                        // we definitely know we are doing an update here.
                        newDependOM.setDeleted(false);
                        parentIssueOM
                          .doChangeDependencyType(activitySetOM, oldDependOM, newDependOM, null);
                        LOG.debug("Updated Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("Old Type: " + oldDependOM.getDependType().getName() + " New type: " + newDependOM.getDependType().getName());
                        LOG.debug("----------------------------------------------------");
                    }
                }
                catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }                
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
public void addIssue(final XmlIssue issue)
        throws ScarabException
    {
        LOG.debug("Module.addIssue(): " + issue.getId());
        try
        {
            if (inValidationMode)
            {
                importErrors.setParseContext((issue.hasModuleCode()
                    ?"":module.getCode()) + issue.getId());
                doIssueValidateEvent(getModule(), issue);
            }
            else
            {
                doIssueEvent(getModule(), issue);
            }
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
        catch (ParseException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
        finally
        {
            importErrors.setParseContext(null);
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Issue createNewIssue(final XmlModule module, final XmlIssue issue, final String id)
        throws TorqueException,ScarabException
    {
        // get the instance of the module
        final Module moduleOM = getModuleForIssue(module,issue);
        // get the instance of the issue type
        final IssueType issueTypeOM = IssueType.getInstance(issue.getArtifactType());
        issueTypeOM.setName(issue.getArtifactType());
        // get me a new issue since we couldn't find one before
        final Issue issueOM = Issue.getNewInstance(moduleOM, issueTypeOM);

        // The import data may nominate its ID
        if (id != null) {
            // This will cause Issue.save() to use this ID
            issueOM.setFederatedId(id);
        }
        // create the issue in the database

        // Add the mapping between the issue id and the id that was created.
        // This mapping is used dependency checking and printing out in 
        // results list of original id and new id. The original issue id can be
        // null. In this case, have the original id show as 'null (index)'
        // where index is count into the issueXMLMap. We add the index to keep
        // the key unique. This substitute original id also shouldn't interfere
        // w/ issueXMLMap's use dependency checking.
        String issueID = "Null (" + Integer.toString(issueXMLMap.size()) + ")";
        if(issue.getId() != null)
        {
            issueID = (issue.hasModuleCode()?"":module.getCode())
                + issue.getId();
        }
        issueXMLMap.put(issueID, issueOM.getUniqueId());

        LOG.debug("Created new Issue: " + issueOM.getUniqueId());
        return issueOM;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueEvent(final XmlModule module, final XmlIssue issue)
        throws TorqueException,ScarabException,ParseException
    {
/////////////////////////////////////////////////////////////////////////////////  
        // Get me an issue
        Issue issueOM = null;
        final String issueID = (issue.hasModuleCode() ? "" : module.getCode()) + issue.getId();
        if (getImportTypeCode() == CREATE_SAME_DB || getImportTypeCode() == CREATE_DIFFERENT_DB)
        {
            // Check if the new issue nominates an ID and if the database does
            // not already contain an issue with that ID
            if (issue.getId() != null && IssueManager.getIssueById(issueID) == null)
            {
                // Create the new issue with the nominated ID
                issueOM = createNewIssue(module, issue, issue.getId());
            }
            else
            {
                // Crate the new issue with an automatically allocated ID
                issueOM = createNewIssue(module, issue, null);
            }
        }
        else if (getImportTypeCode() == UPDATE_SAME_DB) // nice to specify just for searching/refactoring
        {
            issueOM = IssueManager.getIssueById(issueID);
            
            if (issueOM == null)
            {
                issueOM = createNewIssue(module, issue, null);
            }
            else
            {
                LOG.debug("Found Issue in db: " + issueOM.getUniqueId());
            }
        }

/////////////////////////////////////////////////////////////////////////////////  

        // Loop over the XML activitySets
        final List activitySets = issue.getActivitySets();
        LOG.debug("-----------------------------------");
        LOG.debug("Number of ActivitySets in Issue: " + activitySets.size());
        for (Iterator itr = activitySets.iterator(); itr.hasNext();)
        {
            final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
            LOG.debug("Processing ActivitySet: " + activitySet.getId());

/////////////////////////////////////////////////////////////////////////////////  
            // Deal with the attachment for the activitySet
            final XmlAttachment activitySetAttachment = activitySet.getAttachment();
            Attachment activitySetAttachmentOM = null;
            if (activitySetAttachment != null)
            {
                if (getImportTypeCode() == UPDATE_SAME_DB)
                {
                    try
                    {
                        activitySetAttachmentOM = AttachmentManager
                            .getInstance(activitySetAttachment.getId());
                        LOG.debug("Found existing ActivitySet Attachment");
                    }
                    catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
                }
                else
                {
                    activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    LOG.debug("Created ActivitySet Attachment object");
                }
            }
            else
            {
                LOG.debug("OK- No Attachment in this ActivitySet");
            }

/////////////////////////////////////////////////////////////////////////////////  
            // Attempt to get the activitySet OM
            boolean alreadyCreated = false;
            ActivitySet activitySetOM = null;
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                try
                {
                    activitySetOM = ActivitySetManager.getInstance(activitySet.getId());
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in db: " + activitySetOM.getActivitySetId());
                }
                catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            }
            else
            {
                // first try to get the ActivitySet from the internal map
                if (activitySetIdMap.containsKey(activitySet.getId()))
                {
                    activitySetOM = ActivitySetManager.getInstance(
                        (String)activitySetIdMap.get(activitySet.getId()));
                    alreadyCreated = true;
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in map: " + activitySetOM.getActivitySetId());
                }
                else // it hasn't been encountered previously
                {
                    activitySetOM = ActivitySetManager.getInstance();
                    LOG.debug("Created new ActivitySet");
                }
            }

            final ScarabUser activitySetCreatedByOM = findUser(activitySet.getCreatedBy());
            
            if (LOG.isDebugEnabled())
            {
                LOG.debug("ActivitySet: " + activitySet.getId() + "; of type: " + activitySet.getType() + "; by: " + activitySet.getCreatedBy());
                LOG.debug("   alreadyCreated: " + alreadyCreated);
            }
            
            if (!alreadyCreated)
            {
                // Populate the ActivitySet
                // Get the ActivitySet type/createdby values (we know these are valid)
                final ActivitySetType ttOM = ActivitySetTypeManager.getInstance(activitySet.getType());
                activitySetOM.setActivitySetType(ttOM);
                if( activitySetCreatedByOM != null ){
                    activitySetOM.setCreatedBy(activitySetCreatedByOM.getUserId());
                }
                else
                {
                	// Anonymous user. better than nothing.
                	try {
						activitySetOM.setCreatedBy(ScarabUserManager.getAnonymousUser().getUserId());
					} catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                }
                activitySetOM.setCreatedDate(activitySet.getCreatedDate().getDate());
                if (activitySetAttachmentOM != null)
                {
                    activitySetAttachmentOM.save();
                    activitySetOM.setAttachment(activitySetAttachmentOM);
                }
                activitySetOM.save();
                if( activitySet.getId() != null){
                    // if id is valid, save for later re-use.
                    activitySetIdMap.put(activitySet.getId(), 
                                         activitySetOM.getPrimaryKey().toString());
                }
            }

            // Determine if this ActivitySet should be marked as the 
            // creation event
            final ActivitySet creationSet = issueOM.getActivitySetRelatedByCreatedTransId();
            if (ActivitySetTypePeer.CREATE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) 
               ||
               (ActivitySetTypePeer.MOVE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) && 
                        (creationSet == null || activitySetOM.getCreatedDate()
                         .before(creationSet.getCreatedDate()))) ) 
            {
                issueOM.setActivitySetRelatedByCreatedTransId(activitySetOM);
                issueOM.save();
            }

/////////////////////////////////////////////////////////////////////////////////  
// Deal with changing user attributes. this code needs to be in this *strange*
// location because we look at the entire activityset in order to determine
// that this is a change user activity set. of course in the future, it would
// be really nice to create an activityset/activiy type that more accurately 
// reflects what type of change this is. so that it is easier to case for. for
// now, we just look at some fingerprints to determine this information. -JSS

            if (activitySet.isChangeUserAttribute())
            {
                final List activities = activitySet.getActivities();
                final XmlActivity activityA = (XmlActivity)activities.get(0);
                final XmlActivity activityB = (XmlActivity)activities.get(1);
                
                final ScarabUser assigneeOM = findUser(activityA.getOldUser());
                final ScarabUser assignerOM = findUser(activityB.getNewUser());

                final Attribute oldAttributeOM = Attribute.getInstance(activityA.getAttribute());

                final AttributeValue oldAttValOM = issueOM.getUserAttributeValue(assigneeOM, oldAttributeOM);
                if (oldAttValOM == null)
                {
                    LOG.error("User '" + assigneeOM.getName() + "' was not previously '" + oldAttributeOM.getName() + "' to the issue!");
                }

                // Get the Attribute associated with the new Activity
                final Attribute newAttributeOM = Attribute.getInstance(activityB.getAttribute());

                issueOM.changeUserAttributeValue(activitySetOM,
                            assigneeOM, 
                            assignerOM, 
                            oldAttValOM,
                            newAttributeOM, null);
                LOG.debug("-------------Updated User AttributeValue------------");
                continue;
            }

/////////////////////////////////////////////////////////////////////////////////  

            // Deal with the activities in the activitySet
            final List activities = activitySet.getActivities();
            LOG.debug("Number of Activities in ActivitySet: " + activities.size());

            final LinkedMap avMap = issueOM.getModuleAttributeValuesMap();
            LOG.debug("Total Module Attribute Values: " + avMap.size());
            for (Iterator itrb = activities.iterator(); itrb.hasNext();)
            {
                final XmlActivity activity = (XmlActivity) itrb.next();
                LOG.debug("Looking at activity id: " + activity.getId());

                // Get the Attribute associated with the Activity
                final Attribute attributeOM = Attribute.getInstance(activity.getAttribute());

                // deal with the activity attachment (if there is one)
                final XmlAttachment activityAttachment = activity.getAttachment();
                Attachment activityAttachmentOM = null;
                if (activityAttachment != null)
                {
                    // look for an existing attachment in the activity
                    // the case is when we have a URL and we create it
                    // and then delete it, the attachment id is still the
                    // same so there is no reason to re-create the attachment
                    // again.
                    final String previousXmlId = activityAttachment.getId();
                    final String previousId = (String)attachmentIdMap.get(previousXmlId);
                    if (previousId == null) 
                    {
                        activityAttachmentOM = createAttachment(issueOM, activityAttachment);
                        activityAttachmentOM.save();
                        attachmentIdMap.put(previousXmlId, activityAttachmentOM.getPrimaryKey().toString());
                        
                        // Special case. After the Attachment object has been 
                        // saved, if the ReconcilePath == true, then assume 
                        // that the fileName is an absolute path to a file and
                        // copy it to the right directory
                        // structure under Scarab's path.
                        if (allowFileAttachments && activityAttachment.getReconcilePath())
                        {
                            try
                            {
                                activityAttachmentOM
                                    .copyFileFromTo(activityAttachment.getFilename(), 
                                                    activityAttachmentOM.getFullPath());
                            } 
                            catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            } 
                            catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                        }
                        LOG.debug("Created Activity Attachment object");
                    }
                    else 
                    {
                        activityAttachmentOM = AttachmentManager
                            .getInstance(previousId);
                        LOG.debug("Found existing Activity Attachment");
                    }
                }
                else
                {
                    LOG.debug("OK- No Attachment in this Activity");
                }

                // deal with null attributes (need to do this before we create the 
                // activity right below because this will create its own activity).
                if (attributeOM.equals(nullAttribute))
                {
                    // add any dependency activities to a list for later processing
                    if (isDependencyActivity(activity))
                    {
                        if (!isDuplicateDependency(activity))
                        {
                            final Object[] obj = {activitySetOM, activity, activityAttachmentOM};
                            allDependencies.add(obj);
                            dependActivitySetId.add(activity.getDependency());
                            LOG.debug("-------------Stored Dependency # " 
                                    + allDependencies.size() + '[' + activity.getDependency() + ']');
                            continue;
                        }
                    }
                    else
                    {
                        // create the activity record.
                        ActivityManager.createTextActivity(issueOM, nullAttribute, activitySetOM, 
                                    ActivityType.getActivityType(activity.getActivityType()), activity.getDescription(), activityAttachmentOM, 
                                    activity.getOldValue(), activity.getNewValue());
        
                        LOG.debug("-------------Saved Null Attribute-------------");
                        continue;
                    }
                }

                // create the activityOM
                createActivity(activity, module, 
                                            issueOM, attributeOM, activitySetOM);

                // check to see if this is a new activity or an update activity
                AttributeValue avalOM = null;
                for (Iterator moduleAttributeValueItr = avMap.mapIterator(); 
                     moduleAttributeValueItr.hasNext() && avalOM == null;)
                {
                    final AttributeValue testAvalOM = (AttributeValue)
                        avMap.get(moduleAttributeValueItr.next());
                    final Attribute avalAttributeOM = testAvalOM.getAttribute();

                    LOG.debug("Checking Attribute match: " + avalAttributeOM.getName() + 
                              " against: " + attributeOM.getName());
                    if (avalAttributeOM.equals(attributeOM))
                    {
                        avalOM = testAvalOM;
                    }
                }

                if (avalOM != null) 
                {
                    final Attribute avalAttributeOM = avalOM.getAttribute();
                    LOG.debug("Attributes match!");
                    AttributeValue avalOM2 = null;
                    if (!activity.isNewActivity())
                    {
                        LOG.debug("Activity is not new.");
                        avalOM2 = AttributeValue.getNewInstance(
                            avalAttributeOM.getAttributeId(), 
                            avalOM.getIssue());
                        avalOM2.setProperties(avalOM);
                    }

                    if (avalAttributeOM.isOptionAttribute())
                    {
                        LOG.debug("We have an Option Attribute: " + 
                                  avalAttributeOM.getName());
                        final AttributeOption newAttributeOptionOM = 
                                AttributeOptionManager.getInstance(
                                         attributeOM, activity.getNewOption(),
                                         issueOM.getModule(),
                                         issueOM.getIssueType());
                        if (activity.isNewActivity())
                        {
                            if (newAttributeOptionOM != null)
                            {
                                avalOM.setOptionId(newAttributeOptionOM.getOptionId());
                                avalOM.startActivitySet(activitySetOM);
                                avalOM.setAttribute(attributeOM);
                                avalOM.save();
                                LOG.debug("-------------Saved Attribute Value-------------");
                            }
                            else
                            {
                                LOG.warn("NewAttributeOptionOM is null for " +
                                         activity.getNewOption());
                            }
                        }
                        else if(newAttributeOptionOM != null)
                        {
                            avalOM2.setOptionId(newAttributeOptionOM.getOptionId());
                            final HashMap map = new HashMap();
                            map.put(avalOM.getAttributeId(), avalOM2);
                            issueOM.setAttributeValues(activitySetOM, map, null, activitySetCreatedByOM);
                            LOG.debug("-------------Saved Option Attribute Change-------------");
                        }
                    }
                    else if (avalAttributeOM.isUserAttribute())
                    {
                        LOG.debug("We have a User Attribute: " 
                                  + avalAttributeOM.getName());
                        if (activity.isNewActivity())
                        {
                            // Don't need to pass in the attachment because
                            // it is already in the activitySetOM.
                            // If we can't get an assignee new-user, then 
                            // use the activity set creator as assignee.
                            ScarabUser assigneeOM = findUser(activity.getNewUser());
                            assigneeOM = (assigneeOM != null)
                                ? assigneeOM: activitySetCreatedByOM;
                            if( assigneeOM != null ){
                                issueOM.assignUser(activitySetOM, 
                                    assigneeOM, null, avalAttributeOM, null);
                            }
                            LOG.debug("-------------Saved User Assign-------------");
                        }
                        else if (activity.isRemoveUserActivity())
                        {
                            // remove a user activity
                            final ScarabUser oldUserOM = findUser(activity.getOldUser());
                            // need to reset the aval because the current one
                            // is marked as new for some reason which causes an
                            // insert and that isn't the right behavior here 
                            // (we want an update)
                            avalOM = null;
                            for (Iterator i = issueOM.getAttributeValues(
                                 avalAttributeOM).iterator(); 
                                 i.hasNext() && avalOM == null;) 
                            {
                                final AttributeValue av = (AttributeValue)i.next();
                                if (oldUserOM.getUserId().equals(av.getUserId())) 
                                {
                                    avalOM = av;
                                }
                            }

                            if (avalOM == null) 
                            {
                                if (LOG.isDebugEnabled()) 
                                {
                                    LOG.debug("Could not find previous AttributeValue assigning " +
                                        (oldUserOM == null ? "NULL" : 
                                        oldUserOM.getUserName()) + 
                                        " to attribute " + 
                                              avalAttributeOM.getName());
                                }                                
                            }
                            else 
                            {
                                // don't need to pass in the attachment because
                                // it is already in the activitySetOM
                                issueOM.deleteUser(activitySetOM, oldUserOM, 
                                    activitySetCreatedByOM, avalOM, null);
                                LOG.debug("-------------Saved User Remove-------------");
                            }
                        }
                    }
                    else if (avalAttributeOM.isTextAttribute() || avalAttributeOM.isIntegerAttribute())
                    {
                        LOG.debug("We have a Text Attribute: " + avalAttributeOM.getName());

                        avalOM.startActivitySet(activitySetOM);
                        avalOM.setAttribute(attributeOM);

                        if (activity.isNewActivity())
                        {
                            avalOM.setValue(activity.getNewValue());
                        }
                        else if (!activity.getNewValue()
                                .equals(avalOM.getValue()))
                        {
                            avalOM2.setValue(activity.getNewValue());
                            avalOM.setProperties(avalOM2);
                        }
                        
                        avalOM.save();
                        LOG.debug("-------------Saved Attribute Value-------------");
                    }
                }
                issueOM.save();
                LOG.debug("-------------Saved Issue-------------");
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Activity createActivity(final XmlActivity activity,  
                                         final XmlModule module,
                                         final Issue issueOM, 
                                         final Attribute attributeOM,
                                         final ActivitySet activitySetOM)
        throws TorqueException, ParseException, ScarabException
    {
        Activity activityOM = null;
        if (getImportTypeCode() == UPDATE_SAME_DB)
        {
            try
            {
                activityOM = ActivityManager.getInstance(activity.getId());
            }
            catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
        }
        else
        {
            activityOM = ActivityManager.getInstance();
        }

        activityOM.setIssue(issueOM);
        activityOM.setAttribute(attributeOM);
        activityOM.setActivityType(ActivityType.OTHER.getCode());
        activityOM.setActivitySet(activitySetOM);
        if (activity.getEndDate() != null)
        {
            activityOM.setEndDate(activity.getEndDate().getDate());
        }

        // Set the attachment for the activity
        Attachment newAttachmentOM = null;
        if (activity.getAttachment() != null)
        {
            newAttachmentOM = createAttachment(issueOM, activity.getAttachment());
            newAttachmentOM.save();
            activityOM.setAttachment(newAttachmentOM);
        }

        LOG.debug("Created New Activity");
        return activityOM;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Attachment createAttachment(final Issue issueOM, 
            final XmlAttachment attachment)
        throws TorqueException, ScarabException, ParseException
    {
        final Attachment attachmentOM = AttachmentManager.getInstance();
        attachmentOM.setIssue(issueOM);
        final AttachmentType type = AttachmentType.getInstance(attachment.getType());
        if (allowFileAttachments || !Attachment.FILE__PK.equals(type.getAttachmentTypeId())) 
        {
            attachmentOM.setName(attachment.getName());
            attachmentOM.setAttachmentType(type);
            attachmentOM.setMimeType(null != attachment.getMimetype()
                    ? attachment.getMimetype()
                    : ComponentLocator.getMimeTypeService().getContentType(attachment.getFilename(), null));
            attachmentOM.setFileName(attachment.getFilename());        
            attachmentOM.setData(attachment.getData());
        }
        else 
        {
            // add a comment that the file will not be imported.  An alternative would be
            // to skip the activity altogether, but we will then need to check that there 
            // are other activities or we need to completely ignore the ActivitySet
            attachmentOM.setName("comment");
            attachmentOM.setTypeId(Attachment.COMMENT__PK);
            attachmentOM.setMimeType("text/plain");
            String text = "File, " + attachment.getFilename() + 
                ", was not imported. The old description follows:\n\n" + attachment.getName();
            final String data = attachment.getData();  // this should be null, but just in case
            if (data != null) 
            {
                text += "\n\n" + data;
            }
            attachmentOM.setData(text);
        }
        
        attachmentOM.setCreatedDate(attachment.getCreatedDate().getDate());
        final ModifiedDate modifiedDate = attachment.getModifiedDate();
        if (modifiedDate != null)
        {
            attachmentOM.setModifiedDate(modifiedDate.getDate());
        }
        final ScarabUser creUser = findUser(attachment.getCreatedBy());
        if (creUser != null)
        {
            attachmentOM.setCreatedBy(creUser.getUserId());
        }

        final String modifiedBy = attachment.getModifiedBy();
        if (modifiedBy != null)
        {
            final ScarabUser modUserOM = findUser(attachment.getModifiedBy());
            if (modUserOM != null)
            {
                attachmentOM.setModifiedBy(modUserOM.getUserId());
            }
        }

        attachmentOM.setDeleted(attachment.getDeleted());
        return attachmentOM;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private ScarabUser findUser(final String userStr) 
        throws TorqueException,ScarabException
    {
        
        ScarabUser user = ScarabUserManager.getInstance(userStr);
        if (user == null && userStr != null && userStr.indexOf("@") <0 )
        {
            LOG.debug("user specified possibly by email address: "+userStr);
            // maybe it's an email not a username
            user = ScarabUserManager.getInstanceByEmail(userStr);
            LOG.debug("found "+user);
        }
        return user;        
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Module getModuleForIssue(final XmlModule module, final XmlIssue issue)
        throws TorqueException, ScarabException
    {
        
        if(issue.hasModuleCode() && !issue.getModuleCode().equals(module.getCode()) && !allowGlobalImport){
            throw new ScarabException(
                    new L10NKey("Lacking permission to cross-module import. Contact your administor. <localize me>"));
        }
        
        return issue.hasModuleCode()
                ? ModuleManager.getInstance(module.getDomain(),
                                            null,issue.getModuleCode())
                : ModuleManager.getInstance(module.getDomain(),
                                            module.getName(), module.getCode());
     }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public void init()
        throws ScarabException,MalformedURLException,IOException
    {
        TurbineInitialization.setTurbineResources(getTurbineResources());
        TurbineInitialization.setUp(getConfigDir().getAbsolutePath(), 
            getConfigFile());
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public void execute() 
        throws ScarabException
    {
        runImport(getXmlFile());
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public Collection runImport(final File importFile)
        throws ScarabException
    {
        return runImport(importFile, (Module) null);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public Collection runImport(final File importFile, final Module currentModule)
        throws ScarabException
    {
        return runImport(importFile.getAbsolutePath(), importFile,
                         currentModule, SCARAB);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public Collection runImport(final FileItem importFile)
        throws ScarabException
    {
        return runImport(importFile, (Module) null, SCARAB);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
public Collection runImport(final FileItem importFile, 
            final Module currentModule,
            final ImportType type)
        throws ScarabException
    {
        return runImport(importFile.getName(), importFile, currentModule, type);
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected Collection runImport(final String filePath, 
            final Object input,
            final Module currentModule,
            final ImportType type)
        throws ScarabException
    {
        
        final String msg = "Importing issues from XML '" + filePath + '\'';
        LOG.debug(msg);
        try
        {
            // Disable workflow and set file attachment flag
            WorkflowFactory.setForceUseDefault(true);
            
            final Reader is = getScarabFormattedReader(input,type,currentModule);
            
            final BeanReader reader = createScarabIssuesBeanReader();
            validate(filePath, is, reader, currentModule);

            if (importErrors == null || importErrors.isEmpty())
            {
                // Reget the input stream.
                si = insert(filePath, getScarabFormattedReader(input,type,currentModule), reader);
            }
        }
        catch (ParserConfigurationException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (IOException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (IntrospectionException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (SAXException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (JDOMException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
        catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
        finally
        {
            // Re-enable workflow.
            WorkflowFactory.setForceUseDefault(false);
        }

        return importErrors;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected ScarabIssues insert(
            final String name, 
            final Reader is, 
            final BeanReader reader)
        throws ParserConfigurationException,SAXException,IOException,ScarabException, TorqueException
    {
        setValidationMode(reader, false);
        final ScarabIssues si = (ScarabIssues)reader.parse(is);
        si.doHandleDependencies();
        LOG.debug("Successfully imported " + name + '!');
        return si;
    }
            
// in java/org/tigris/scarab/util/TurbineInitialization.java
public static void setUp(final String configDir, final String configFile)
        throws ScarabException,MalformedURLException,IOException
    {
        if (configDir == null || configFile == null)
        {
            System.err.println("config.dir System property was not defined");
            throw new ScarabException (new L10NKey("configDir or configFile was null")); // FIXME localise
        }

        // set this so that the proper substitution will happen in the
        // configFile
        System.getProperties().setProperty("configDir", configDir);

        initTurbine(configDir);
        
        final InputStream is = new File(configDir + configFile).toURL()
            .openStream();
        final Properties props = new Properties();
        try
        {
            props.load(is);
            // init Log4J
            PropertyConfigurator.configure(props);
        }
        catch (Exception e)
        {
            System.err.println("Can't read the properties file (" + 
                configDir + configFile + "). ");
        }
    }
14 
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (ScarabException e)
        {
            setAlertMessage(e.getL10nMessage());
        }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (ScarabException e) {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/actions/TemplateList.java
catch (ScarabException e)
                {
                    success = false;
                    scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
                }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch (ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
            
// in java/org/tigris/scarab/actions/admin/Approval.java
catch(ScarabException e)
                       {
                           L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric,e);
                           scarabR.setAlertMessage(msg);
                       }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabException e)
                    {
                        scarabR.setAlertMessage(l10n.getMessage(e));
                        Log.get().warn(
                            "This is an application error, if it is not permission related.", e);
                    }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    scarabR.setAlertMessage(l10n.getMessage(se));
                }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
            {
                childId.setMessage(se.getL10nMessage().getMessage(l10n));
                return false;
            }
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
catch (ScarabException se)
                {
                    // it will error out if they attempt to delete
                    // a dep via a child dep.
                    String l10nKey = se.getMessage();
                    scarabR.setAlertMessage(l10n.get(l10nKey));
                }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
3 
            
// in java/org/tigris/scarab/om/Issue.java
catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (ScarabException e) {
                throw new RuntimeException(e);
            }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (ScarabException e)
        {
            LOG.error(msg, e);
            throw e; //EXCEPTION
        }
1
unknown (Domain) ScarabLocalizedTorqueException 
public class ScarabLocalizedTorqueException extends TorqueException implements Localizable
{
    private final Throwable throwable;

    // may be null
    private ScarabLocalizationTool localizer;
    
    /**
     * Constructs a TorqueException wrapper for a given throwable.
     * The wrapper is simply a container with no special
     * functionality.
     * @param e
     */
    public ScarabLocalizedTorqueException(final Throwable t)
    {
        throwable = t;
        localizer = null;
    }

    /**
     * Set the localizer to be used in later calls to {@link #getLocalizedMessage()}
     * @param theLocalizer the localizer (may be <code>null</code>)
     */
     public void setLocalizer(final ScarabLocalizationTool theLocalizer)
     {
        localizer = theLocalizer;
     }
    
    /**
     * Delegator for the wrapped exceptions getMessage() method.
     * @return the wrapped exception's message
     */
    public String getMessage()
    {
        return throwable.getMessage();
    }


    /**
     * Localize this exception using the wrapped throwable.
     * return the localized message, else return the message string
     * of the wrapped throwable.
     * @param l10n
     * @return
     */
    public String getMessage(final ScarabLocalizationTool l10n)
    {
        return l10n.getMessage(throwable);
    }    

    /**
     * Return the localized message for that throwable, if a localizer
     * was defined using {@link #setLocalizer(ScarabLocalizationTool)}
     * @return the localized message.
     */
    public String getLocalizedMessage()
    {   
        if (localizer != null)
        {
            return getMessage(localizer);
        } 
        else
        {
            return super.getLocalizedMessage();
        }
    }
}
 		7 
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void save(final Connection dbCon) 
        throws TorqueException
    {
        // if new, make sure the code has a value.
        if (isNew())
        {

            List result;
            try {
                result = getDuplicatesByNameAndParent(getRealName(), getParentId());
            }
            catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
            if (result.size() > 0)
            {
                throw new ScarabLocalizedTorqueException(
                        new ScarabException(
                                L10NKeySet.ExceptionModuleAllreadyExists,
                        getRealName(), 
                        getParent().getName()));
            }

            final String code = getCode();
            if (code == null || code.length() == 0)
            {
                if (getParentId().equals(ROOT_ID))
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionTopLevelModuleWithoutCode));
                }

                try
                {
                    setCode(getParent().getCode());
                }
                catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            }

            // need to do this before the relationship save below
            // in order to set the moduleid for the new module.
            super.save(dbCon);
            try
            {
                dbCon.commit();
            }
            catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
            if (getOwnerId() == null) 
            {
                throw new ScarabLocalizedTorqueException(new  ScarabException(L10NKeySet.ExceptionSaveNeedsOwner));
            }
            // grant the ower of the module the Project Owner role
            try
            {
                final User user = ScarabUserManager.getInstance(getOwnerId());
 
                final Role role = TurbineSecurity.getRole(PROJECT_OWNER_ROLE);
                grant (user, role);
                setInitialAttributesAndIssueTypes();
            }
            catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
        }
        else
        {
            super.save(dbCon);
        }
        
        // clear out the cache beause we want to make sure that
        // things get updated properly.
        ScarabCache.clear();
    }
4 
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
0 1 
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (ScarabLocalizedTorqueException slte) 
                        {
                            String msg = slte.getMessage(l10n);
                            scarabR.setAlertMessage(msg);
                        }
0 0
unknown (Domain) ScarabLocalizedTurbineSecurityException 
public class ScarabLocalizedTurbineSecurityException extends TurbineSecurityException implements Localizable
{
    private final Throwable throwable;

    // may be null
    private ScarabLocalizationTool localizer;
    
    
    /**
     * Constructs a TurbineSecurityException wrapper for a given exception.
     * The wrapper is simply a container with no special
     * functionality.
     * @param e
     */
    public ScarabLocalizedTurbineSecurityException(final Throwable t)
    {
        super("");
        throwable = t;
        localizer = null;
    }
    
    /**
     * Set the localizer to be used in later calls to {@link #getLocalizedMessage()}
     * @param theLocalizer the localizer (may be <code>null</code>)
     */
     public void setLocalizer(final ScarabLocalizationTool theLocalizer)
     {
        localizer = theLocalizer;
     }
    
    /**
     * Delegator for the wrapped exceptions getMessage() method.
     * @return the wrapped exception's message
     */
    public String getMessage()
    {
        return throwable.getMessage();
    }


    /**
     * Localize this exception using the wrapped exception.
     * return the localized message, else return the message string
     * of the wrapped exception.
     * @param l10n
     * @return
     */
    public String getMessage(final ScarabLocalizationTool l10n)
    {
        return l10n.getMessage(throwable);
    }    
    
    /**
     * Return the localized message for that throwable, if a localizer
     * was defined using {@link #setLocalizer(ScarabLocalizationTool)}
     * @return the localized message.
     */
    public String getLocalizedMessage()
    {   
        if (localizer != null)
        {
            return getMessage(localizer);
        } 
        else
        {
            return super.getLocalizedMessage();
        }
    }

}
 		0 0 0 0 0 0
runtime (Domain) ScarabRuntimeException 
public class ScarabRuntimeException extends RuntimeException //implements Localizable
{
    /**
     * The exception message in non-localized form.
     * Further infos, see the {@link #getMessage(L10N) getmessage } methods below.
     */
    Localizable l10nMessage;
    
    /**
     * Placeholder for a nested exception (may be null)
     */
    Throwable nested;

    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * resource and no parameters.
     * @param theKey the l10n error key.
     */
    public ScarabRuntimeException(LocalizationKey theKey)
    {
         l10nMessage = new L10NMessage(theKey);
         nested      = null;
    }

    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * resource and a nested Throwable.
     * @param theKey the l10n error key.
     * @param aNested
     */
    public ScarabRuntimeException(LocalizationKey theKey, Throwable aNested)
    {
        super();
        l10nMessage = new L10NMessage(theKey, nested);
        nested      = aNested;
    }


    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * Localizable .
     * @param theL10nInstance the l10n error key.
     */
    public ScarabRuntimeException(Localizable theL10nInstance)
    {
         l10nMessage = theL10nInstance;
         nested      = null;
    }
 
    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * Localizable and a nested Throwable.
     * @param theL10nInstance the l10n error key.
     * @param aNested
     */
    public ScarabRuntimeException(Localizable theL10nInstance, Throwable aNested)
    {
        super();
        l10nMessage = theL10nInstance;
        nested      = aNested;
    }

    
    /**
     * Constructs a new <code>ScarabRuntimeException</code> with specified 
     * resource and a list of parameters.
     * @param theL10nInstance the l10n error key.
     * @param theParams
     */
    public ScarabRuntimeException (LocalizationKey theKey, Object[] theParams)
    {
        l10nMessage = new L10NMessage(theKey, theParams);
        nested      = null;
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource and one parameter.
     * @param theL10nInstance the l10n error key.
     * @param p1
     */
    public ScarabRuntimeException (LocalizationKey theKey, Object p1)
    {
        this(theKey, new Object[] {p1});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource and two parameters.
     * @param theL10nInstance the l10n error key.
     * @param p1
     * @param p2
     */
    public ScarabRuntimeException (LocalizationKey theKey, Object p1, Object p2)
    {
        this(theKey, new Object[] {p1, p2});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource and three parameters.
     * @param theL10nInstance the l10n error key.
     * @param p1
     * @param p2
     * @param p3
     */
    public ScarabRuntimeException (LocalizationKey theKey, Object p1, Object p2, Object p3)
    {
        this(theKey, new Object[] {p1, p2, p3});
    }
  

    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource, nested Throwable and an aritrary set of parameters.
     * 
     * @param theKey
     * @param nested
     * @param theParams
     */
    public ScarabRuntimeException (LocalizationKey theKey, Throwable nested, Object[] theParams)
    {
        this(new L10NMessage(theKey, theParams),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource, nested Throwable and one parameter.
     * @param theKey
     * @param nested
     * @param p1
     */
    public ScarabRuntimeException (LocalizationKey theKey, Throwable nested, Object p1)
    {
        this(new L10NMessage(theKey, p1),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource, nested Throwable and two parameters.
     * @param theKey
     * @param nested
     * @param p1
     * @param p2
     */
    public ScarabRuntimeException (LocalizationKey theKey, Throwable nested, Object p1, Object p2)
    {
        this(new L10NMessage(theKey, p1, p2),nested);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabRuntimeException</code>
     * with specified resource, nested Throwable and three parameters.
     * @param theKey
     * @param nested
     * @param p1
     * @param p2
     * @param p3
     */
    public ScarabRuntimeException (LocalizationKey theKey, Throwable nested, Object p1, Object p2, Object p3)
    {
        this(new L10NMessage(theKey, p1, p2, p3),nested);
    }

    /**
     * return the L10NInstance, or null, if no L10N key was given.
     * @return
     */
    public Localizable getL10nMessage()
    {
        return l10nMessage;
    }
    
    /** 
     * return the localized message by use of the
     * given ScarabLocalizationTool. For further infos see
     * {@link #getMessage() getMessage }
     *
     * @deprecated Does not follow core java patterns. Use setLocalizer(..) then getLocalizedMessage() instead.     
     *
     * @param l10n
     * @return
     */
    public String getMessage(ScarabLocalizationTool l10n)
    {
        String result;
        if (l10nMessage == null)
        {
            if (nested == null)
            {
                result = super.getMessage();
            }
            else
            {
                if (  nested instanceof ScarabRuntimeException )
                {
                    result = ((ScarabRuntimeException)nested).getMessage(l10n);
                }
                else if (  nested instanceof ScarabException )
                {
                    result = ((ScarabException)nested).getMessage(l10n);
                }
                else
                {
                    result = nested.getMessage();
                }
            }
        }
        else
        {
            result = l10nMessage.getMessage(l10n);
        }
        return result;
    }
 
    /**
     * return the localized message in english.
     * Note: It is preferrable to use 
     * {@link #getMessage(ScarabLocalizationTool) getMessage }
     *
     * @return localized english text
     */
    public String getMessage()
    {
        String result;
        if (l10nMessage == null)
        {
            if (nested == null)
            {
                result = super.getMessage();
            }
            else
            {
                result = nested.getMessage();
            }
        }
        else
        {
            result = l10nMessage.getMessage();
        }
        return result;
    }

}
 		8 
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void save() 
    {
        try
        {
            
            super.save();
        }
        catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/services/ServiceManager.java
public synchronized Object lookup(Class serviceClass)
    {
        Object serviceInstance;
        YaafiComponentService yaafi = getService();
        try{
            serviceInstance =  yaafi.lookup(serviceClass.getName());
        } 
        catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
        return serviceInstance;
    }
            
// in java/org/tigris/scarab/services/ServiceManager.java
public static YaafiComponentService getService()
    {
        YaafiComponentService yaafi = null;
        try{
            yaafi = (YaafiComponentService) TurbineServices.getInstance().getService(
                    YaafiComponentService.SERVICE_NAME);
        } 
        catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
        return yaafi;
        
    }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }

        JCSCache = JCS.getInstance(SCARAB_CACHE_REGION);

        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x);
        }

    }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
public void initialize() throws Exception
    {
        try
        {
            poolService = (PoolService) manager.lookup(PoolService.ROLE);
        }
        catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
        maps = new WeakHashMap();
        try
        {
            keyClass = Class
                .forName("org.tigris.scarab.services.cache.ScarabCacheKey");
        }
        catch (Exception x)
        {
            throw new InitializationException(
                "Failed to initialize ScarabCache",x); //EXCEPTION
        }
        
    }
            
// in java/org/tigris/scarab/services/cache/ScarabCache.java
public static final ScarabCacheService getService() {
        if (scarabCacheService == null) {
            try {
                ServiceManager sm = ServiceManager.getInstance();
                scarabCacheService = (ScarabCacheService) sm.lookup(ScarabCacheService.class);
            } catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
        }
        return scarabCacheService;
    }
            
// in java/org/tigris/scarab/util/ComponentLocator.java
private static Object lookup(Class clazz) 
    {
		try 
        {
            ServiceManager sm = ServiceManager.getInstance();
			return sm.lookup(clazz);
		} catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
	}
            
// in java/org/tigris/scarab/util/word/SearchFactory.java
public static LuceneSearchIndex getInstance()  
    {
        LuceneSearchIndex result = LuceneSearchIndex;

        if (result == null) 
        {
            
            try{
                ServiceManager sm = ServiceManager.getInstance();
                return (LuceneSearchIndex) sm.lookup(LuceneSearchIndex.class);
            } 
            catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
        }
        return result;
    }
8 
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/ServiceManager.java
catch (Exception e) 
        {
            L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionGeneric, e);
            throw new ScarabRuntimeException(msg);
        }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/DefaultScarabCacheService.java
catch (Exception e)
        {
            throw new ScarabRuntimeException(
               L10NKeySet.ExceptionScarabCacheService, e);
        }
            
// in java/org/tigris/scarab/services/cache/ScarabCache.java
catch (Exception e) {
                throw new ScarabRuntimeException(
                        L10NKeySet.ExceptionScarabCacheService, e);
            }
            
// in java/org/tigris/scarab/util/ComponentLocator.java
catch (Exception e) 
        {
			throw new ScarabRuntimeException(
			        L10NKeySet.ExceptionComponentLocator,
				    clazz.getName(),
				    e);
		}
            
// in java/org/tigris/scarab/util/word/SearchFactory.java
catch (Exception e) {
                throw new ScarabRuntimeException(L10NKeySet.ExceptionLucene, e);
            }
0 0 0 0
checked (Domain) ScarabUpdateException 
public class ScarabUpdateException extends Exception {

    public ScarabUpdateException(String string) {
        super(string);
    }

}
 		2 
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        // find the corresponding attribute
        Attribute attr;
        Criteria crit = new Criteria();
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        List attrList = AttributePeer.doSelect(crit);
        if (attrList.size() == 1) {
            attr = (Attribute) attrList.get(0);
        } else {
            throw new ScarabUpdateException(
                    "Found " + attrList.size() + " attributes for " + attribute + ".");
        }
        return attr;
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getOptionAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        Attribute attr = getAttribute(attribute);
        if (attr.isOptionAttribute()) {
            // do nothing
        } else {
            throw new ScarabUpdateException(
                    "Found non-optiontype attribute when an option type attribte was expected.");
        }
        return attr;
    }
0 5 
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        // find the corresponding attribute
        Attribute attr;
        Criteria crit = new Criteria();
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        List attrList = AttributePeer.doSelect(crit);
        if (attrList.size() == 1) {
            attr = (Attribute) attrList.get(0);
        } else {
            throw new ScarabUpdateException(
                    "Found " + attrList.size() + " attributes for " + attribute + ".");
        }
        return attr;
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getOptionAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        Attribute attr = getAttribute(attribute);
        if (attr.isOptionAttribute()) {
            // do nothing
        } else {
            throw new ScarabUpdateException(
                    "Found non-optiontype attribute when an option type attribte was expected.");
        }
        return attr;
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public List getAttributeOptions(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.add(AttributeOptionPeer.DELETED, false);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                AttributeOptionPeer.ATTRIBUTE_ID);
        return AttributeOptionPeer.doSelect(crit);
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private List getModuleAttributes(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                RModuleAttributePeer.ATTRIBUTE_ID);
        List matOptions = RModuleAttributePeer.doSelect(crit);

        return matOptions;
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private List getIssueTypes(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                RIssueTypeAttributePeer.ATTRIBUTE_ID);
        crit.addJoin(IssueTypePeer.ISSUE_TYPE_ID,
                RIssueTypeAttributePeer.ISSUE_TYPE_ID);
        List itOptions = IssueTypePeer.doSelect(crit);

        return itOptions;
    }
0 0 0
unknown (Lib) SchedulerException 0 0 0 1 
            
// in java/org/tigris/scarab/notification/NotificationManagerJob.java
catch (SchedulerException e) {
			log.error("execute(): " + e);
		}
0 0
unknown (Lib) ServiceException 1 
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private final void renderingError(String filename, Throwable e)
        throws ServiceException
    {
        String err = "Error rendering Velocity template: " + filename;
        getCategory().error(err + ": " + e.getMessage());
        // if the Exception is a MethodInvocationException, the underlying
        // Exception is likely to be more informative, so rewrap that one.
        if (e instanceof MethodInvocationException)
        {
            e = ((MethodInvocationException)e).getWrappedThrowable();
        }

        throw new ServiceException(err, e); //EXCEPTION
    }
0 15 
            
// in java/org/tigris/scarab/actions/ModifyIssue.java
private REASON_SAVE_MODE saveReason(RunData data, final boolean isReasonRequired,
            final Group reasonGroup) throws ServiceException 
    {
        REASON_SAVE_MODE saveMode = REASON_SAVE_MODE.NONE;
        if(reasonGroup != null)
        {
        	// The reasonField is visible, so we can process it
            final Field reasonField = reasonGroup.get("Data");
            
            if(isReasonRequired)
            {
                reasonField.setRequired(true);
            }
            
            // make sure to trim the whitespace
            String reasonFieldString = reasonField.toString();
            if (reasonFieldString != null)
            {
                reasonFieldString = reasonFieldString.trim();
            }
            String saveAsFieldString = data.getParameters().get("saveReasonAs");
            if (saveAsFieldString != null)
            {
                saveAsFieldString = saveAsFieldString.trim();
            }
            final boolean saveAsComment = "Comment".equalsIgnoreCase(saveAsFieldString);
            saveMode = (saveAsComment)? REASON_SAVE_MODE.COMMENT:REASON_SAVE_MODE.HISTORY;
            
            if (!reasonField.isValid() || reasonFieldString.length() == 0)
            {
                if (isReasonRequired)
                {
                    reasonField.setMessage(
                        "ExplanatoryReasonRequiredToModifyAttributes");
                }
            }
        }
        return saveMode;
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static void handleRequest(Context context, String filename, 
                                     Writer writer)
        throws ServiceException
    {
        getService().handleRequest(context, filename, writer, null);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmail.java
public static void handleRequest(Context context, String filename,
                                     Writer writer, String encoding)
        throws ServiceException
    {
        getService().handleRequest(context, filename, writer, encoding);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public String handleRequest(TemplateContext context, String template)
        throws ServiceException
    {
        return handleRequest(new ContextAdapter(context), template);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public String handleRequest(Context context, String filename)
        throws ServiceException
    {
        return handleRequest(context, filename, (String)null, null);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public String handleRequest(Context context, String filename,
                                String charset, String encoding)
        throws ServiceException
    {
        String results = null;
        if (charset == null)
        {
            StringWriter writer = null;
            try
            {
                writer = new StringWriter();
                handleRequest(context, filename, writer, encoding);
                results = writer.toString();
            }
            catch (Exception e)
            {
                renderingError(filename, e);
            }
            finally
            {
                try
                {
                    if (writer != null)
                    {
                        writer.close();
                    }
                }
                catch (IOException ignored)
                {
                }
            }
        }
        else 
        {
        ByteArrayOutputStream bytes = null;
        try
        {
            bytes = new ByteArrayOutputStream();
            charset = decodeRequest(context, filename, bytes, charset,
                                    encoding);
            results = bytes.toString(charset);
        }
        catch (Exception e)
        {
            renderingError(filename, e);
        }
        finally
        {
            try
            {
                if (bytes != null)
                {
                    bytes.close();
                }
            }
            catch (IOException ignored)
            {
            }
        }
        }
        
        return results;
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(TemplateContext context, String template,
                              OutputStream outputStream)
        throws ServiceException
    {
        handleRequest(new ContextAdapter(context), template, outputStream);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(Context context, String filename,
                              OutputStream output)
        throws ServiceException
    {
        handleRequest(context, filename, output, null, null);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(Context context, String filename,
                              OutputStream output, String charset,
                              String encoding)
        throws ServiceException
    {
        decodeRequest(context, filename, output, charset, encoding);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(TemplateContext context,
                                       String template, Writer writer)
        throws ServiceException
    {
        handleRequest(new ContextAdapter(context), template, writer);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(Context context, String filename,
                              Writer writer)
        throws ServiceException
    {
        handleRequest(context, filename, writer, null);
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
public void handleRequest(Context context, String filename,
                              Writer writer, String encoding)
        throws ServiceException
    {
        try
        {
            // If the context is not already an instance of
            // InternalEventContext, wrap it in a VeclocityContext so that
            // event cartridges will work. Unfortunately there is no interface
            // that extends both Context and InternalEventContext, so this
            // is not as clear as it could be.

            Context eventContext;

            if ( context instanceof InternalEventContext )
            {
                eventContext = context;
            }
            else
            {
                eventContext = new VelocityContext( context );
            }

            if (encoding == null)
            {
                encoding = DEFAULT_CHAR_SET;
            }

            // Request scoped encoding first supported by Velocity 1.1.
            velocityEngine.mergeTemplate(filename, encoding,
                                         eventContext, writer);
        }
        catch (Exception e)
        {
            renderingError(filename, e);
        }
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private String decodeRequest(Context context, String filename,
                                 OutputStream output, String charset,
                                 String encoding)
        throws ServiceException
    {
        if (charset == null)
        {
            charset = DEFAULT_CHAR_SET;
        }

        OutputStreamWriter writer = null;
        try
        {
            try
            {
                writer = new OutputStreamWriter(output, charset);
            }
            catch (Exception e)
            {
                renderingError(filename, e);
            }
            handleRequest(context, filename, writer, encoding);
        }
        finally
        {
            try
            {
                if (writer != null)
                {
                    writer.flush();
                }
            }
            catch (Exception ignored)
            {
            }
        }
        return charset;
    }
            
// in java/org/tigris/scarab/services/email/VelocityEmailService.java
private final void renderingError(String filename, Throwable e)
        throws ServiceException
    {
        String err = "Error rendering Velocity template: " + filename;
        getCategory().error(err + ": " + e.getMessage());
        // if the Exception is a MethodInvocationException, the underlying
        // Exception is likely to be more informative, so rewrap that one.
        if (e instanceof MethodInvocationException)
        {
            e = ((MethodInvocationException)e).getWrappedThrowable();
        }

        throw new ServiceException(err, e); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/email/TemplateHtmlEmail.java
protected String handleRequest(final String template,
                                   final boolean bEscapeHTML)
        throws ServiceException
    {
        StringWriter sw = new StringWriter();
        
        ScarabLocalizationTool l10n = (ScarabLocalizationTool)
                context.get(ScarabConstants.LOCALIZATION_TOOL);
        
        if (l10n != null)
        {
            final boolean pushFilterEnable = l10n.isFilterEnabled();

            if (bEscapeHTML == true)
            {
                l10n.setFilterEnabled(false);
            }
        
            try
            {
                VelocityEmail.handleRequest(new ContextAdapter(context), template, sw);
            }
            finally
            {
                l10n.setFilterEnabled(pushFilterEnable);
            }
        }
        else
        {
            VelocityEmail.handleRequest(new ContextAdapter(context), template, sw);
        }

        return sw.toString();
    }
0 0 0
unknown (Lib) ServletException 1 
            
// in java/org/tigris/scarab/tools/install/web/SaveSettingsServlet.java
public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		String redirect = null;
		Properties properties = (Properties) request.getSession().getAttribute("properties");
		
		Map parameterMap = request.getParameterMap( );
		if (parameterMap == null)
	        throw new ServletException("getParameterMap returned null in: " + getClass( ).getName( ));

		Iterator iterator = parameterMap.entrySet( ).iterator( );
		while(iterator.hasNext( )){
			Map.Entry me = (Map.Entry)iterator.next( );
			String key = (String) me.getKey();
			String[] arr = (String[]) me.getValue( );
			String value = arr[0];
			System.out.println("Key: [" + key + "] Value: [" + value + "]");

			if ("redirect".equals(me.getKey())) {
				redirect = value;
			}

			if (key.indexOf('.') != -1) {
				properties.setProperty(key, value);
			}
		}

		if (redirect == null) {
			System.out.println("ERROR: no redirect specified, redirect to BasicSettings.jsp");
		}
		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL(redirect));
	}
0 7 
            
// in java/org/tigris/scarab/tools/install/web/InitServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		System.out.println("User dir:" + System.getProperty("user.dir"));
		System.out.println("Now reading project.properties");
		Properties properties = new Properties();
	    try {
	        properties.load(new FileInputStream("../../project.properties"));
	    } catch (IOException e) {
	    	e.printStackTrace();
	    }

	    try {
	        properties.load(new FileInputStream("../../build.properties"));
	    } catch (IOException e) {
	    	System.out.println("There is probably no build.properties file.");
	    }
	    
	    // Init HTTP scheme information
	    // Since the installer runs in the same container as the Scarab to
	    // be built, getting these informations from the request probably
	    // makes more sense than the default values.
	    properties.setProperty("scarab.http.scheme", request.getScheme());
	    properties.setProperty("scarab.http.domain", request.getServerName());
	    properties.setProperty("scarab.http.port", new Integer(request.getServerPort()).toString());
	    
	    // Init additional properties for the database generation.
	    properties.setProperty("skip.seed.data", "false");
	    properties.setProperty("skip.jira.templates.data", "false");
	    
	    request.getSession().setAttribute("properties", properties);
	    
		response.sendRedirect(response.encodeRedirectURL("BasicSettings.jsp"));
	}
            
// in java/org/tigris/scarab/tools/install/web/SaveSettingsServlet.java
public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		String redirect = null;
		Properties properties = (Properties) request.getSession().getAttribute("properties");
		
		Map parameterMap = request.getParameterMap( );
		if (parameterMap == null)
	        throw new ServletException("getParameterMap returned null in: " + getClass( ).getName( ));

		Iterator iterator = parameterMap.entrySet( ).iterator( );
		while(iterator.hasNext( )){
			Map.Entry me = (Map.Entry)iterator.next( );
			String key = (String) me.getKey();
			String[] arr = (String[]) me.getValue( );
			String value = arr[0];
			System.out.println("Key: [" + key + "] Value: [" + value + "]");

			if ("redirect".equals(me.getKey())) {
				redirect = value;
			}

			if (key.indexOf('.') != -1) {
				properties.setProperty(key, value);
			}
		}

		if (redirect == null) {
			System.out.println("ERROR: no redirect specified, redirect to BasicSettings.jsp");
		}
		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL(redirect));
	}
            
// in java/org/tigris/scarab/tools/install/web/BuildScarabServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		PrintWriter out = response.getWriter();
		
		try {
			ResourceBundle rb = ResourceBundle.getBundle("InstallBundle");

			File currentDirectory = new File(System.getProperty("user.dir"));
			String buildDirectoryName = currentDirectory.getParentFile().getParentFile().getAbsolutePath() + File.separatorChar + "build";
			String commandLine1 = null;
			
			// Write a couple of batch (command) file
			// I could not find another way to launch ant in another directory
			if ("Windows".equals(System.getProperty("os.name").substring(0, 7))) {
		        BufferedWriter batch1 = new BufferedWriter(new FileWriter("build-scarab.cmd"));
		        batch1.write("cd " + buildDirectoryName + "\r\n");
		        batch1.write("ant\r\n");
		        batch1.close();
		        
		        commandLine1 = "cmd /c build-scarab.cmd";
			} else {
		        BufferedWriter batch1 = new BufferedWriter(new FileWriter("build-scarab"));
		        batch1.write("#! /bin/sh\n");
		        batch1.write("cd " + buildDirectoryName + "\n");
		        batch1.write("ant\n");
		        batch1.close();
		        
		        commandLine1 = "sh ./build-scarab";
			}

			// Launch first batch to build Scarab
			out.println("<div class=\"infomessage\">");
			out.println("<strong>Phase 1</strong> : " + rb.getString("building.scarab.application"));
			out.println("</div>");
			
			Process child = Runtime.getRuntime().exec(commandLine1);
			
			out.println("<pre>");
			InputStream in = child.getInputStream();
			int c;
			while ((c = in.read()) != -1) {
				out.print((char) c);
			}
			out.println("</pre>");
			in.close();
			
			if (child.exitValue() == 0) {
				out.println("<p class=\"infomark\">" + rb.getString("success") + "</p>");
			} else {
				out.println("<p class=\"errormark\">" + rb.getString("failure") + "</p>");
			}
		} catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		} catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
			
		}
		
	}
            
// in java/org/tigris/scarab/tools/install/web/Build1Servlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		Properties properties = (Properties) request.getSession().getAttribute("properties");
		System.out.println("Now writing the build.properties file.");
		properties.store(new FileOutputStream("../../build.properties"), "Generated by ScarabWebInstaller");
		System.out.println("Done.");
		
		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL("Build1.jsp"));

	}
            
// in java/org/tigris/scarab/tools/install/web/Build2Servlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		response.setContentType("text/html");
		response.sendRedirect(response.encodeRedirectURL("Build2.jsp"));

	}
            
// in java/org/tigris/scarab/tools/install/web/BuildDatabaseServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		PrintWriter out = response.getWriter();
		

		try {
			ResourceBundle rb = ResourceBundle.getBundle("InstallBundle");

			File currentDirectory = new File(System.getProperty("user.dir"));
			String buildDirectoryName = currentDirectory.getParentFile().getParentFile().getAbsolutePath() + File.separatorChar + "build";
			String commandLine2 = null;
			
			// Write a couple of batch (command) file
			// I could not find another way to launch ant in another directory
			if ("Windows".equals(System.getProperty("os.name").substring(0, 7))) {
		        BufferedWriter batch2 = new BufferedWriter(new FileWriter("build-scarab-db.cmd"));
		        batch2.write("cd " + buildDirectoryName + "\r\n");
		        batch2.write("ant create-db\r\n");
		        batch2.close();
		        
		        commandLine2 = "cmd /c build-scarab-db.cmd";
			} else {
		        BufferedWriter batch2 = new BufferedWriter(new FileWriter("build-scarab-db"));
		        batch2.write("#! /bin/sh\n");
		        batch2.write("cd " + buildDirectoryName + "\n");
		        batch2.write("ant\n");
		        batch2.close();
		        
		        commandLine2 = "sh ./build-scarab-db";
			}

			// Launch second batch to build the Scarab database
			out.println("<div class=\"infomessage\">");
			out.println("<strong>Phase 2</strong> : " + rb.getString("building.scarab.database"));
			out.println("</div>");
			
			Process child = Runtime.getRuntime().exec(commandLine2);
			
			out.println("<pre>");
			InputStream in = child.getInputStream();
			int c;
			while ((c = in.read()) != -1) {
				out.print((char) c);
			}
			out.println("</pre>");
			in.close();
			
			if (child.exitValue() == 0) {
				out.println("<p class=\"infomark\">" + rb.getString("success") + "</p>");
			} else {
				out.println("<p class=\"errormark\">" + rb.getString("failure") + "</p>");
			}
		} catch (MissingResourceException mre) {
			System.out.println("Something is wrong with the installation, I could not find the InstallBundle*.properties resource bundles");
		} catch (Exception e) {
			out.println("<div class=\"errormessage\">");
			out.println("An error occured, stack trace follows: ");
			out.println("</div>");
			out.println("<pre>");
			e.printStackTrace(out);
			out.println("</pre>");
		}
		
	}
            
// in java/org/tigris/scarab/util/AntServlet.java
public final void init(ServletConfig config)
        throws ServletException
    {
        super.init(config);

        String command = config.getInitParameter("buildCommand");
        if (command != null)
        {
            buildCommand = command;
            System.out.println ("AntServlet Command: " + 
                buildCommand);
        }
        String file = config.getInitParameter("buildFile");
        if (file != null)
        {
            buildFile = new File(file);
            System.out.println ("AntServlet File: " + 
                buildFile.getAbsolutePath());
        }
    }
1 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (ServletException e)
                {
                    log.error("authenticateNtlm: " + e);
                }
0 0
unknown (Lib) SmbAuthException 0 0 0 1 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (SmbAuthException sae)
            {
                response.setHeader("WWW-Authenticate", "NTLM");
                response.setHeader("Connection", "close");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.flushBuffer();
                return;
            }
0 0
unknown (Lib) TooManyRowsException 0 0 0 5 
            
// in java/org/tigris/scarab/om/Transition.java
catch (TooManyRowsException e)
        {
            //Nothing to do, just ignore it
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TooManyRowsException e)
            {
                //Nothing to do, just ignore it
            }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TooManyRowsException e)
        {
            //Nothing to do, just ignore it
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TooManyRowsException e)
        {
            // Nothing to do. Ignore.
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TooManyRowsException e) {
                    log.error("Too many rows when sorting IssueTypeOptions.",e);
                }
0 0
unknown (Lib) TorqueException 42 
            
// in java/org/tigris/scarab/om/AttributeValue.java
public static synchronized AttributeValue getNewInstance(
        Attribute attribute, Issue issue) throws TorqueException
    {
        AttributeValue attv = null;
        try
        {
            String className = attribute
                .getAttributeType().getJavaClassName();
            attv = (AttributeValue)
                Class.forName(className).newInstance();
            attv.setAttribute(attribute);
            attv.setIssue(issue);
    
            attv.init();
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        return attv;
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void save(Connection dbcon)
        throws TorqueException
    {
        if (isModified() && !getAttribute().isUserAttribute())
        {
            try
            {
                checkActivitySet(L10NKeySet.ExceptionCanNotSaveAttributeValue);
            }
            catch (Exception e)
            {
                throw new TorqueException(e);
            }
            if (saveActivity == null)
            {            
                if (getDeleted())
                {
                    saveActivity = ActivityManager
                        .create(getIssue(), getAttribute(), activitySet, 
                                ActivityType.ATTRIBUTE_CHANGED, null, null, getNumericValue(), ScarabConstants.INTEGER_0,
                                getUserId(), null, getOptionId(), null, 
                                getValue(), null, dbcon);
                }
                else
                {
                    saveActivity = ActivityManager
                        .create(getIssue(), getAttribute(), activitySet, 
                                ActivityType.ATTRIBUTE_CHANGED, null, null, oldNumericValue, getNumericValue(),
                                oldUserId, getUserId(), oldOptionId, getOptionId(), 
                                oldValue, getValue(), dbcon);
                }
            }
        }
        super.save(dbcon);
        if (chainedValue != null) 
        {
            chainedValue.save(dbcon);
        }
        endActivitySet();
    }
            
// in java/org/tigris/scarab/om/Query.java
public void setModule(Module me)
        throws TorqueException
    {
        if (me == null) 
        {
            setModuleId((Integer)null);            
        }
        else 
        {
            Integer id = me.getModuleId();
            if (id == null) 
            {
                throw new TorqueException("Modules must be saved prior to " +
                    "being associated with other objects."); //EXCEPTION
            }
            setModuleId(id);
        }        
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity create(Issue issue, Attribute attribute,
                       ActivitySet activitySet, ActivityType type, 
                       String description, Attachment attachment, Depend depend,
                       Integer oldNumericValue, Integer newNumericValue,
                       Integer oldUserId, Integer newUserId,
                       Integer oldOptionId, Integer newOptionId,
                       String oldTextValue, String newTextValue, 
                       Connection dbCon)
         throws TorqueException
    {
        Activity activity = ActivityManager.getInstance();
        activity.setIssue(issue);
        if (attribute == null)
        {
            attribute = Attribute.getInstance(0);
        }
        activity.setAttribute(attribute);
        activity.setActivitySet(activitySet);
        activity.setOldNumericValue(oldNumericValue);
        activity.setNewNumericValue(newNumericValue);
        activity.setOldUserId(oldUserId);
        activity.setNewUserId(newUserId);
        activity.setOldOptionId(oldOptionId);
        activity.setNewOptionId(newOptionId);
        activity.setOldValue(oldTextValue);
        activity.setNewValue(newTextValue);
        activity.setDepend(depend);
        activity.setDescription(description);
        activity.setActivityType(type!=null?type.getCode():null);
        if (attachment != null)
        {
            activity.setAttachment(attachment);
        }
        if (dbCon == null) 
        {
            try
            {
                activity.save();
            }
            catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        else 
        {
            activity.save(dbCon);
        }
        // Make sure new activity is added to activity cache
        try
        {
            issue.addActivity(activity);
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        return activity;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void save(Connection con) throws TorqueException
    {
        if (isModified())
        {
            if (isNew())
            {
                super.save(con);
            }
            else
            { 
                RIssueTypeAttribute ria = null;
                try
                {
                    ria = getIssueType().getRIssueTypeAttribute(getAttribute());
                    if ((ria != null && ria.getLocked()))
                    {
                    throw new TorqueException(getAttribute().getName() + " is locked"); //EXCEPTION
                    }
                    else
                    {
                        super.save(con);
                    }
                }
                catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public void save(Connection con) throws TorqueException
    {
        if (isModified())
        {
            if (isNew())
            {
                super.save(con);
            }
            else
            {
                Attribute attr = getAttributeOption().getAttribute();
                RIssueTypeAttribute ria = null;
                try
                {
                    ria = getIssueType().getRIssueTypeAttribute(attr);
                    if (ria != null && ria.getLocked())
                    {
                        throw new TorqueException(attr.getName() + "is locked"); //EXCEPTION
                    }
                    else
                    {
                        super.save(con);
                    }
                }
                catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
private void addAncestors(AttributeOption option)
        throws TorqueException, Exception
    {
        if (!ROOT_ID.equals(option.getParent().getOptionId()))
        {
            if (ancestors.contains(option.getParent()))
            {
                throw new TorqueException("Tried to add a recursive parent-child " +
                                    "attribute option relationship."); //EXCEPTION
            }
            else
            { 
                addAncestors(option.getParent());
            }
        }
        ancestors.add(option.getOptionId());
    }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static NotificationRule getNotificationRule(Integer moduleId, Integer userId, String activityType) throws ScarabException
    {
        NotificationRule rule = null;
        
        int managerId = NotificationManagerFactory.getInstance().getManagerId();
        Criteria crit = new Criteria();
        crit.add(NotificationRulePeer.USER_ID, userId);
        crit.add(NotificationRulePeer.MODULE_ID, moduleId);
        crit.add(NotificationRulePeer.ACTIVITY_TYPE, activityType);
        crit.add(NotificationRulePeer.MANAGER_ID, managerId);
                
        try
        {
            List<NotificationRule> ruleSet = (List<NotificationRule>)NotificationRulePeer.doSelect(crit);     
            if(ruleSet == null || ruleSet.size()==0)
            {

                rule = NotificationRule.createDefaultRule( 
                       moduleId, 
                       userId,
                       managerId,
                       activityType);
            }
            else if (ruleSet.size() > 1)
            {
                String msg = "Database inxonsistency:"
                           + " Expected at most one key matching (user_id,module_id,activity_type,manager_id) = "
                           + ")" + userId + "," + moduleId + "," + activityType + "," + managerId + ")";
                throw new TorqueException(msg,new Throwable());
            }
            else
            {
                rule = ruleSet.get(0);
            }
        }
        catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }

        return rule;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public AttributeOption getAttributeOption(String optionID)
        throws TorqueException
    {
        if (optionID == null || optionID.length() == 0)
        {
            throw new TorqueException("optionId is empty"); //EXCEPTION
        }
        return getAttributeOption(new Integer(optionID));
    }
            
// in java/org/tigris/scarab/om/Issue.java
public static List parseIssueList(final Module module, final String theList)
        throws TorqueException, DataSetException
    {
        final String[] issues = StringUtils.split(theList, ",");
        final List results = new ArrayList();
        for (int i = 0; i < issues.length; i++)
        {
            if (issues[i].indexOf('*') != -1)
            {
                // Probably better to use more Torque here, but this
                // is definitely going to be faster and more
                // efficient.
                final String sql = "SELECT CONCAT(" + IssuePeer.ID_PREFIX + ',' +
                    IssuePeer.ID_COUNT + ") FROM " + IssuePeer.TABLE_NAME +
                    " WHERE " + IssuePeer.ID_PREFIX + " = '" +
                    module.getCode() + '\'';
                final List records = BasePeer.executeQuery(sql);
                for (Iterator j = records.iterator(); j.hasNext();)
                {
                    final Record rec = (Record)j.next();
                    results.add(rec.getValue(1).asString());
                }
            }
            // check for a -
            else if (issues[i].indexOf('-') == -1)
            {
                // Make sure user is not trying to access issues from another
                // module.
                final FederatedId fid = createFederatedId(module, issues[i]);
                if (!fid.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    final String[] args = { fid.getPrefix(), module.getCode() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixNotForModule", args)); //EXCEPTION
                }
                results.add(issues[i]);
            }
            else
            {
                final String[] issue = StringUtils.split(issues[i], "-");
                if (issue.length != 2)
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDRangeNotValid", issues[i])); //EXCEPTION
                }
                FederatedId fidStart = createFederatedId(module, issue[0]);
                FederatedId fidStop = createFederatedId(module, issue[1]);
                if (!fidStart.getPrefix().equalsIgnoreCase(module.getCode()) ||
                    !fidStop.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesNotForModule",
                                         module.getCode())); //EXCEPTION
                }
                else if (!fidStart.getPrefix()
                         .equalsIgnoreCase(fidStop.getPrefix()))
                {
                    final String[] args = { fidStart.getPrefix(),
                                      fidStop.getPrefix() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesDoNotMatch", args)); //EXCEPTION
                }
                else if (fidStart.getCount() > fidStop.getCount())
                {
                    FederatedId swap = fidStart;
                    fidStart = fidStop;
                    fidStop = swap;
                }

                for (int j = fidStart.getCount(); j <= fidStop.getCount();j++)
                {
                    results.add(fidStart.getPrefix() + j);
                }
            }
        }
        return results;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private static FederatedId createFederatedId(Module module, String id)
        throws TorqueException
    {
        FederatedId fid = null;
        try
        {
            fid = new FederatedId(id.trim());
            if (fid.getPrefix() == null || fid.getPrefix().length() == 0)
            {
                fid.setPrefix(module.getCode());
            }
        }
        catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
        return fid;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/Issue.java
protected Set<ScarabUser> getUsersToEmail(String action, Issue issue, Set<ScarabUser> users)
        throws TorqueException
    {
        if (users == null)
        {
            users = new HashSet<ScarabUser>(1);
        }

        Module module = getModule();

        ScarabUser createdBy = issue.getCreatedBy();
        if (createdBy != null && !users.contains(createdBy) &&
            AttributePeer.EMAIL_TO.equals(action) &&
               createdBy.hasPermission(ScarabSecurity.ISSUE__ENTER, module))
        {
            users.add(createdBy);
        }

        Criteria crit = new Criteria()
            .add(AttributeValuePeer.ISSUE_ID, issue.getIssueId())
            .addJoin(AttributeValuePeer.ATTRIBUTE_ID,
                     AttributePeer.ATTRIBUTE_ID)
            .add(AttributePeer.ACTION, action)
            .add(RModuleAttributePeer.MODULE_ID, getModuleId())
            .add(RModuleAttributePeer.ISSUE_TYPE_ID, getTypeId())
            .add(AttributeValuePeer.DELETED, 0)
            .add(RModuleAttributePeer.ACTIVE, true)
            .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                     AttributeValuePeer.ATTRIBUTE_ID);
        List userAttVals = AttributeValuePeer.doSelect(crit);
        for (Iterator i = userAttVals.iterator(); i.hasNext(); )
        {
            AttributeValue attVal = (AttributeValue) i.next();
            try
            {
                ScarabUser su = ScarabUserManager
                    .getInstance(attVal.getUserId());
                if (!users.contains(su)
                    && su.hasPermission(attVal.getAttribute().getPermission(),
                                        module))
                {
                    users.add(su);
                }
            }
            catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Set<ScarabUser> getAllUsersToEmail(String action) throws TorqueException
    {
        Set<ScarabUser> result = null;
        Object obj = ScarabCache.get(this, GET_ALL_USERS_TO_EMAIL, action); 
        if (obj == null) 
        {        
            Set<ScarabUser> users = new HashSet<ScarabUser>();
            try
            {
                users = getUsersToEmail(action, this, users);
                List children = getChildren();
                for (int i=0;i<children.size();i++)
                {
                    Issue depIssue = IssueManager.getInstance
                        (((Depend) children.get(i)).getObserverId());
                    users = getUsersToEmail(action, depIssue, users);
                }
                result = users;
            }
            catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            ScarabCache.put(result, this, GET_ALL_USERS_TO_EMAIL, action);
        }
        else 
        {
            result = (Set)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void addActivity(Activity activity) throws TorqueException  
    {
        List activityList = null;
        try
        {
            activityList = getActivity(true);
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        super.addActivity(activity);
        if (!activityList.contains(activity))
        {
            activityList.add(activity);
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void save(Connection dbCon)
        throws TorqueException
    {
        Module module = getModule();
        if (!module.allowsIssues() || (isNew() && !module.allowsNewIssues())) 
        {
            throw new UnsupportedOperationException(module.getName() + 
                " does not allow issues."); //EXCEPTION
        }
        
        // remove unset AttributeValues before saving
        List attValues = getAttributeValues();
        // reverse order since removing from list
        for (int i=attValues.size()-1; i>=0; i--) 
        {
            AttributeValue attVal = (AttributeValue) attValues.get(i);
            if (!attVal.isSet()) 
            {
                attValues.remove(i);
            }
        }

        if (isNew())
        {
            // set the issue id
            setIdDomain(module.getScarabInstanceId());
            setIdPrefix(module.getCode());

            // for an enter issue template, do not give issue id
            // set id count to -1 so does not show up as an issue
            if (isTemplate())
            { 
                setIdCount(-1);
            }
            else
            {
                try
                {
                    final int suggestedID = getIdCount();
                    if (suggestedID != 0) {
                        // Force the next available issue ID to be the
                        // nominated value, if not out of sequence.
                        // TODO: assert that this issue doesn't already exist
                        // In this case, just skip the next action.
                        setNextIssueId(dbCon, suggestedID);
                    }
                    
                    // Set the ID to the next available value.
                    setIdCount(getNextIssueId(dbCon));
                }
                catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        if(  getActivitySetRelatedByLastTransId()==null
           ||getActivitySetRelatedByCreatedTransId()==null)
        {
            throw new RuntimeException("Created or Last ActivitySet must not be null.");
        }
        super.save(dbCon);
    }
            
// in java/org/tigris/scarab/om/Issue.java
private void saveIdTableKey(final Connection dbCon, final int nextID)
        throws TorqueException
    {
        int id = 0;
        final DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        final IDBroker idbroker = dbMap.getIDBroker();
        final String idTable = IDBroker.TABLE_NAME.substring(0, 
        IDBroker.TABLE_NAME.indexOf('.'));
        try
        {
            id = idbroker.getIdAsInt(dbCon, idTable);
        }
        catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }

        final String key = getIdTableKey();

        // FIXME: UGLY! IDBroker doesn't have a Peer yet.
        final String sql = "insert into " + idTable 
         + " (ID_TABLE_ID,TABLE_NAME,NEXT_ID,QUANTITY) "
         + " VALUES (" + id + ",'" + key + "'," + nextID + ",1)" ;
        BasePeer.executeStatement(sql, dbCon);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setInitialAttributeValues(ActivitySet activitySet, 
            Attachment attachment, 
            final HashMap newValues, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check new values for workflow
        final String msg = doCheckInitialAttributeValueWorkflow(newValues, user);
        if (msg != null)
        {
            throw new TorqueException(msg); //EXCEPTION
        }
        
        if (activitySet == null)
        {
            // Save activitySet record
            activitySet = ActivitySetManager
                .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
            activitySet.save();
        }
        setActivitySetRelatedByCreatedTransId(activitySet);

        // enter the values into the activitySet
        final LinkedMap avMap = getModuleAttributeValuesMap(); 
        final MapIterator iter = avMap.mapIterator();
        while (iter.hasNext())
        {
            final AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            try
            {
                aval.startActivitySet(activitySet);
            }
            catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
        }        
        this.save();

        // create initial issue creation activity
        ActivityManager.createReportIssueActivity(this, activitySet,  
                Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueCreated"));

        // this needs to be done after the issue is created.
        // check to make sure the attachment has data before submitting it.
        final String attachmentData = attachment.getData();
        if (attachmentData != null &&
            attachmentData.length() > 0)
        {
            attachment = AttachmentManager.getReason(attachment, this, user);
            activitySet.setAttachment(attachment);
        }
        activitySet.save();
        
        // need to clear the cache since this is after the 
        // issue is saved. for some reason, things don't
        // show up properly right away.
        ScarabCache.clear();
        
        index();
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setPasswordExpire(Calendar expire)
        throws TorqueException
    {
        Integer userid = getUserId();
        if (userid == null)
        {
            throw new TorqueException("Userid cannot be null"); //EXCEPTION
        }
        UserPreference up = UserPreferenceManager.getInstance(getUserId());
        if (expire == null)
        {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + 10);
            up.setPasswordExpire(cal.getTime());
        }
        else
        {
            up.setPasswordExpire(expire.getTime());
        }
        up.save();
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public void save(Connection dbCon)
        throws TorqueException
    {
        if (getIssue().isNew()) 
        {
            throw new TorqueException("Cannot save an attachment before saving"
                                      + " the issue to which it is attached."); //EXCEPTION
        }
        // It would be better (from an oo perspective) to do this whenever 
        // setData is called, but we can't be sure the typeId will be 
        // set prior to setting the url, so we will do the check here.
        setData(doMakeURLFromData());

        // need to handle the case where we don't want to be smart
        // and just set the dates to be whatever we want them
        // to be (xml import!).
        if (isNew() && (getCreatedDate() == null && getModifiedDate() == null))
        {
            Date now = new Date();
            setCreatedDate(now);
            setModifiedDate(now);
        }
        else if (isModified()) 
        {
            setModifiedDate(new Date());
        }
        
        super.save(dbCon);
        
        try
        {
            FileItem file = getFile();
            if (file != null) 
            {        
                File uploadFile = 
                    new File(getRepositoryDirectory(),getRelativePath());
                File parent = uploadFile.getParentFile();
                if (!parent.exists()) 
                {
                    mkdirs(parent);
                }                
                file.write(uploadFile);
            }
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/om/DependTypeManager.java
public static DependType getInstance(String dependTypeName)
        throws TorqueException
    {
        DependType result = null;
        Object obj = ScarabCache.get(DEPENDTYPE, FIND_DEPENDTYPE_BY_NAME, 
                                     dependTypeName); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(DependTypePeer.DEPEND_TYPE_NAME, dependTypeName);
            List dependTypes = DependTypePeer.doSelect(crit);
            if (dependTypes == null || dependTypes.size() == 0)
            {
                throw new TorqueException("Invalid issue depend type: " + 
                                    dependTypeName); //EXCEPTION
            }
            result = (DependType)dependTypes.get(0);
            ScarabCache.put(result, DEPENDTYPE, FIND_DEPENDTYPE_BY_NAME, 
                            dependTypeName);
        }
        else 
        {
            result = (DependType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static Class getOMClass(Record record, int offset) 
        throws TorqueException
    {
        Class c = null;
        try
        {
            Integer attId = new Integer(record.getValue(offset-1 + 3)
                                            .asString());
            Attribute attribute = AttributeManager.getInstance(attId);
            String className = attribute.getAttributeType().getJavaClassName();

            c = (Class)classMap.get(className);
            if (c == null) 
            {
                c = Class.forName(className);
                classMap.put(className, c);            
            }
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        
        return c;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if ( id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void deleteAttribute(final Attribute attribute, 
            final ScarabUser user,
            final Module module)
         throws TorqueException, ScarabException
    {                
        String permission = null;
        if (isGlobal())
        {
            permission = (ScarabSecurity.DOMAIN__EDIT);
        }
        else
        {
            permission = (ScarabSecurity.MODULE__CONFIGURE);
        }
        if (user.hasPermission(permission, module))
        {
            final IssueType issueType = getIssueType();
            final IssueType template = IssueTypeManager.getInstance
                                 (issueType.getTemplateId());
            boolean success = true;

            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
            if (isGlobal())
            {
                // This is a global attribute group
                // Remove attribute - issue type mapping
                final List rias = issueType.getRIssueTypeAttributes
                                     (false, AttributePeer.NON_USER);
                if (ria != null) 
                {
                    ria.delete();                    
                }
                if (rias != null) 
                {
                    rias.remove(ria);        
                }
            }
            else
            {
                // Check if attribute is locked
                if (ria != null && ria.getLocked())
                {
                    success = false;
                    throw new TorqueException(attribute.getName() + "is locked"); //EXCEPTION
                }
                else
                {
                    // Remove attribute - module mapping
                    final List rmas = module.getRModuleAttributes(issueType, false,
                                                            AttributePeer.NON_USER);    
                    final RModuleAttribute rma = module
                        .getRModuleAttribute(attribute, issueType);
                    if(rma != null)rma.delete();
                    WorkflowFactory.getInstance().deleteWorkflowsForAttribute
                                                  (attribute, module, issueType);
                    if(rma != null)rmas.remove(rma);

                    // Remove attribute - module mapping from template type
                    final RModuleAttribute rma2 = module
                                   .getRModuleAttribute(attribute, template);
                    if(rma2 != null)
                    {
                        rma2.delete();
                        rmas.remove(rma2);
                    }
                }
            }

            if (success)
            {
                // Remove attribute - group mapping
                final RAttributeAttributeGroup raag = 
                    getRAttributeAttributeGroup(attribute);
                raag.delete();

                if (attribute.isOptionAttribute())
                {
                    if (isGlobal())
                    { 
                        // global attributeGroup; remove issuetype-option maps
                        final List rios = issueType.getRIssueTypeOptions(attribute);
                        if (rios != null)
                        {
                            for (int i = 0; i<rios.size();i++)
                            {
                                ((RIssueTypeOption) rios.get(i))
                                    .delete(user, module);
                            }
                        }
                    }
                    else
                    {
                        // Remove module-option mapping
                        final List rmos = module.getRModuleOptions(attribute, issueType);
                        if (rmos != null)
                        {
                            rmos.addAll(module.getRModuleOptions(attribute, template));
                            for (int j = 0; j<rmos.size();j++)
                            {
                                final RModuleOption rmo = (RModuleOption)rmos.get(j);
                                 // rmo's may be inherited by the parent module.
                                 // don't delete unless they are directly associated
                                 // with this module.  Will know by the first one.
                                 if (rmo.getModuleId().equals(module.getModuleId())) 
                                 {
                                     rmo.delete();
                                 }
                                 else 
                                 {
                                     break;
                                 } 
                             }
                         }
                     }
                 }
             }
         }
         else
         {
             throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
         }            
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean isVisible4User(ScarabUser user) throws TorqueException
    {
        Role role = this.getRole4View();
        boolean bRdo = false;
        if (role == null)
        {
            bRdo = true;
        }
        else
        {
            if (user != null)
            {
                try
                {
	            AccessControlList acl = TurbineSecurity.getACL(user);
	            GroupSet allGroups = TurbineSecurity.getAllGroups();
                    Group group = allGroups.getGroup(user.getCurrentModule().getName());
                    bRdo = acl.hasRole(role, group);
                }
                catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
                catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
            }
        }
        return bRdo;	
    }
            
// in java/org/tigris/scarab/om/ModuleManager.java
protected Module getInstanceImpl(final String moduleDomain, 
                                     final String moduleRealName, 
                                     final String moduleCode)
        throws TorqueException
    {
        final Criteria crit = new Criteria();
        if( moduleDomain != null )
        {
            crit.add(ScarabModulePeer.DOMAIN, moduleDomain);
        }
        if( moduleRealName != null )
        {
            crit.add(ScarabModulePeer.MODULE_NAME, moduleRealName);
        }
        if( moduleCode != null )
        {
            crit.add(ScarabModulePeer.MODULE_CODE, moduleCode);
        }
        final List result = ScarabModulePeer.doSelect(crit);
        if (result.size() != 1)
        {
            throw new TorqueException ("Selected: " + result.size() + 
                " rows. Expected 1."); //EXCEPTION
        }
        return (Module) result.get(0);
    }
            
// in java/org/tigris/scarab/om/ModuleManager.java
public static List getInstancesFromIssueList(List issues)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        

        List modules = new ArrayList();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            if (issue != null)
            {
                Module module = issue.getModule();
                if (module != null && !modules.contains(module)) 
                {
                    modules.add(module);
                }
            }
            else
            {
                throw new TorqueException("Null issue in list is not allowed."); //EXCEPTION
            }
        }
        return modules;
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void delete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        int nObjectType = data.getParameters().getInt("obj_type");
        Criteria crit = new Criteria();
        switch (nObjectType)
        {
            case ScarabConstants.TRANSITION_OBJECT:
            	Integer tranId = data.getParameters().getInteger("transition_id");
            	crit.add(ConditionPeer.TRANSITION_ID, tranId);
            	TransitionManager.getMethodResult().remove(TransitionManager.getInstance(tranId), TransitionManager.GET_CONDITIONS);
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, 0);
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, 0);
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
        		crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, data.getParameters().getInt("module_id"));
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, data.getParameters().getInt("issueTypeId"));
        		break;
            case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabRequestTool scarabR = getScarabRequestTool(context);
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.deleteConditions(user, module);
                return;
        }
        ConditionPeer.doDelete(crit);
    	ConditionManager.clear();
    	TransitionManager.clear();
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void updateObject(RunData data, TemplateContext context, Integer aConditions[]) throws Exception
    {
        ScarabRequestTool scarabR = getScarabRequestTool(context);
        Integer operator = data.getParameters().getInteger("combineWith");
        switch (data.getParameters().getInt("obj_type"))
        {
            case ScarabConstants.TRANSITION_OBJECT:
                Transition transition = scarabR.getTransition(data.getParameters().getInteger("transition_id"));
            	transition.setConditionsArray(aConditions, operator);
            	transition.save();
            	TransitionManager.getMethodResult().remove(transition, TransitionManager.GET_CONDITIONS);
                AttributeManager.clear();        
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                Attribute attribute = scarabR.getAttribute(data.getParameters().getInteger("attId"));
            	attribute.setConditionsArray(aConditions, operator);
            	attribute.save();
                AttributeManager.clear();        
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
            	RModuleAttribute rma = RModuleAttributePeer.retrieveByPK(data.getParameters().getInteger("moduleId"), data.getParameters().getInteger("attId"), data.getParameters().getInteger("issueTypeId"));
                rma.setConditionsArray(aConditions, operator);
                RModuleAttributeManager.clear();
                ConditionManager.clear();
                rma.save(); /** TODO: do we need it? **/
                AttributeManager.clear();        
        		break;
        	case ScarabConstants.BLOCKED_MODULE_ISSUE_TYPE_OBJECT:
        	    RModuleIssueType rmit = RModuleIssueTypePeer.retrieveByPK(scarabR.getCurrentModule().getModuleId(), data.getParameters().getInteger("issuetypeid"));
        		rmit.setConditionsArray(aConditions, operator);
        	    rmit.save();
        	    RModuleIssueTypeManager.clear();
        	    ConditionManager.clear();
                AttributeManager.clear();        
        	    break;
        	case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.saveConditions(user, module, aConditions, operator);
        	    break;
        }
    }
16 
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeValue.java
catch (Exception e)
            {
                throw new TorqueException(e);
            }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
            
// in java/org/tigris/scarab/om/ActivityManager.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/RModuleOption.java
catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/Issue.java
catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/Issue.java
catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }
            
// in java/org/tigris/scarab/om/Attachment.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
886 
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public ScarabUser getUser(Object userId) throws TorqueException
    {
        return ScarabUserTool.getUser(userId);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private void ensure_List_has_MIT_data(MITList currentList, Module module, IssueType issueType) throws TorqueException 
    {
        if(currentList != null)
        {
            MITListItem item = currentList.getFirstItem();
            if(item != null)
            {
                if(item.getModule() == null)
                {
                    // Ensure the item has been assigned to a module
                    item.setModule(module);
                }

                IssueType itemIssueType = item.getIssueType();
                if(itemIssueType == null)
                {
                    // item's issueType has not beeen initialized ?
                    if(issueType == null)
                    {                        
                        // Our local IssueType has also not been created ??
                        issueType = new IssueType();
                    }
                    item.setIssueType(issueType);
                    itemIssueType = issueType;
                }
                if (itemIssueType.getIssueTypeId() == null)
                {
                    // No definition means "Do not care". Hence it is equal to "any issueType from any module":
                    itemIssueType.setIssueTypeId(MITListPeer.ALL_MODULES_ISSUETYPES.intValue());
                }
            }
            
        }
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String getRModuleAttributeDisplayName(final Attribute attribute) throws TorqueException
    {
        final ScarabUser user = (ScarabUser)data.getUser();
        MITList mitList = user.getCurrentMITList();
        return getRModuleAttributeDisplayName(attribute, mitList);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String getRModuleAttributeDisplayName(final Attribute attribute, final MITList mitlist)
            throws TorqueException
    {
        return mitlist.getAttributeDisplayName(attribute);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List<RModuleAttribute> getRModuleUserAttributes() throws TorqueException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        Module module   = user.getCurrentModule();
        List<RModuleAttribute> result = getRModuleUserAttributes(user, module);
        return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List<RModuleAttribute> getRModuleUserAttributes(Query q) throws TorqueException
    {
        List<RModuleAttribute> result = getRModuleUserAttributes();
        if(result.size() == 0) 
        {
            /*
             * When we get here, then the current user uses a public query for which
             * he/she has not yet created a customization (ake call s the query for the
             * first time ever). Since we assume, that the original creator of the 
             * query has configured the query wisely, we take a copy of the creators 
             * customization here. Hence the new user gets a reasonable default setting.
             * However the new user can configure the query independently from the originators
             * customization.
             */
            ScarabUser me       = (ScarabUser)data.getUser();  // the userId of the current user
            MITList currentList = q.getMITList();              // The query MIT-list
            ScarabUser owner    = q.getScarabUser();           // The originator of the query
            if(owner==null)
            {
                Log.get().warn("Current Query does not contain a User");
                owner = me;
                if(owner == null)
                {
                    owner = this.getCurrentUser();
                    if(owner == null)
                    {
                        Log.get().warn("Current session has no user assigned. Can not retrieve RModuleUserAttributes.");
                        return result;
                    }
                }
            }
            Module module       = me.getCurrentModule();       // The current module
            IssueType theIssueType = this.getIssueType();      // The current issue Type
            currentList = currentList.copy();                  // Here we make a physical copy
            currentList.setUserId(owner.getUserId());          // We set the current users uid 

            /*
             * Now we recall the Userattributes of the originators customisation,
             * but get it in to our copy. The nice side effect: The copy will be
             * added to the database, thus it gets persistent. Subsequent calls
             * to this method will always return the copy from the database.
            */
            result = getRModuleUserAttributes(owner, module, theIssueType, currentList );
            
        }
        return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private List<RModuleAttribute> getRModuleUserAttributes(ScarabUser user, Module module) throws TorqueException
    {
        Integer defaultIssueTypeId = (Integer)MITListPeer.ALL_MODULES_ISSUETYPES.intValue();
        IssueType theIssueType = this.getIssueType(defaultIssueTypeId);

        if(issueListColumns == null || issueListColumns.size() == 0)
        {
        	issueListColumns= getRModuleUserAttributes(user, module, theIssueType);
			if (issueListColumns == null)
	        {
	            issueListColumns = Collections.EMPTY_LIST;
	        }
        	initialIssueListColumnsSize = issueListColumns.size();
        }

        // DEP: Not sure about this initial list stuff, or if we need it..
        if (initialIssueListColumnsSize > issueListColumns.size())
        {
            TemplateContext context =
                (TemplateContext) data.getTemp(Turbine.CONTEXT);
            context.put("columnLimitExceeded", Boolean.TRUE);
        }
        return issueListColumns;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public Query getQuery() throws TorqueException
    {
        String queryId = data.getParameters().getString("queryId");
        if(queryId==null)
        {
            queryId = data.getParameters().getString("query");
        }
                
        if (queryId != null || query == null)
        {
            query = getQuery(queryId);
        }
        return query;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
private Query getQuery(String queryId) throws TorqueException
    {
        try
        {
            if (queryId == null || queryId.length() == 0)
            {
                query = Query.getInstance();
                Module m = getCurrentModule();
                if(m != null)
                {
                    query.setModule(m);
                }
            }
            else
            {
                query = QueryManager
                      .getInstance(new NumberKey(queryId), false);
            }
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            throw e;
        }
        return query;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueType getIssueType() throws TorqueException
    {
        return getIssueType((Integer)null);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueType getIssueType(Integer defaultIssueTypeId) throws TorqueException
    {
        if (issueType == null)
        {
            String key = data.getParameters()
                .getString("issuetypeid");
            if (key == null)
            {
                // get new issue type
                issueType = new IssueType(defaultIssueTypeId);
            }
            else
            {
                try
                {
                    issueType = IssueTypeManager
                        .getInstance(new NumberKey(key), false);
                }
                catch (Exception e)
                {
                    issueType = new IssueType(defaultIssueTypeId);
                }
            }
        }
        return issueType;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public IssueType getCurrentIssueType()throws TorqueException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        IssueType curit = user.getCurrentIssueType();
        if (curit == null)
        {
            Integer curitID = data.getParameters().getInteger(ScarabConstants.CURRENT_ISSUE_TYPE);
            if(curitID.intValue()!=0)
            {
                curit = IssueTypeManager.getInstance(curitID);
            }
        }
        return curit;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String getNextIssue()
        throws TorqueException
    {
        String nextIssueId = null;
        int nextIssueIndex = getNextIssuePosInList() - 1;
        List searchResults = getCurrentSearchResults();
        if(nextIssueIndex>=0 && nextIssueIndex< searchResults.size() )
        {
            nextIssueId = ((QueryResult)searchResults.get(nextIssueIndex)).getUniqueId();
        }
        return nextIssueId;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public String getPrevIssue()
    throws TorqueException
    {
        String prevIssueId = null;
        int prevIssueIndex = getPrevIssuePosInList() - 1;
        List searchResults = getCurrentSearchResults();
        if(prevIssueIndex>=0 && prevIssueIndex<searchResults.size() )
        {
            prevIssueId = ((QueryResult)searchResults.get(prevIssueIndex)).getUniqueId();
        }
        return prevIssueId;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public static MITListItem convertToMITListItem(RModuleIssueType rmit)
    throws TorqueException
    {
        MITListItem item = MITListItemManager.getInstance();
        item.setModuleId(rmit.getModuleId());
        item.setIssueTypeId(rmit.getIssueTypeId());
        return item;
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public void initializeLink(ScarabLink link)
            throws org.apache.torque.TorqueException
        {
            int offset = listOffset + count;
            link.setPage("ViewIssue.vm")
                .addPathInfo("id", ((QueryResult)current).getUniqueId())
                .addPathInfo(POS_IN_LIST, offset);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getSortedAttributeOptions() throws TorqueException
    {
        return AttributeOptionPeer.getSortedAttributeOptions();
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public List getSortedAttributeOptionsForModule(Module module) throws TorqueException
    {
        return AttributeOptionPeer.getSortedAttributeOptions(module);
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public boolean isAnonymousLoginAllowed()
        throws TorqueException
    {
        return ScarabUserTool.isAnonymousLoginAllowed();
    }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
public RModuleOption getFirstModuleOption(Module module, IssueType issueType, String displayValue) throws TorqueException
    {
        RModuleOption result = null;
        if (module != null && issueType != null && displayValue != null)
        {
            result = RModuleOption.getFirstRMO(module.getModuleId(), issueType.getIssueTypeId(), displayValue);
        }
        return result;
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public boolean hasRequestedRole(ScarabUser user, Role role, Group group)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, HAS_REQUESTED_ROLE, user); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(PendingGroupUserRolePeer.USER_ID, user.getUserId());
            result = PendingGroupUserRolePeer.doSelect(crit);
            ScarabCache.put(result, this, HAS_REQUESTED_ROLE);
        }
        else 
        {
            result = (List)obj;
        }
        boolean b = false;
        Iterator iter = result.iterator();
        while (iter.hasNext()) 
        {
            PendingGroupUserRole pmur = (PendingGroupUserRole)iter.next();
            if (pmur.getRoleName().equals(role.getName())
                && ((Module)group).getModuleId().equals(pmur.getGroupId())) 
            {
                b = true;
                break;
            }
        }
        return b;
    }
            
// in java/org/tigris/scarab/tools/SecurityAdminTool.java
public List getPendingGroupUserRoles(Module module)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_PENDING, module); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(PendingGroupUserRolePeer.GROUP_ID, module.getModuleId());
            result = PendingGroupUserRolePeer.doSelect(crit);
            ScarabCache.put(result, this, GET_PENDING);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static ScarabUser getUser(Object userId)
        throws TorqueException
    {
        if (userId == null)
        {
            return null;
        }

        if(IssueSearch.SEARCHING_USER_KEY.equalsIgnoreCase(userId.toString()))
        {
            return IssueSearch.getSearchingUserPlaceholder();
        }

        Integer pk = null;
        try
        {
            pk = new Integer(userId.toString());
        }
        catch( NumberFormatException e)
        {
            return null;
        }

        ScarabUser su = null;
        try
        {
            su = ScarabUserManager.getInstance(pk);
        }
        catch (TorqueException e)
        {
            return null;
        }
        return su;
    }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static boolean isAnonymousLoginAllowed()
        throws TorqueException
    {
        return ScarabUserManager.anonymousAccessAllowed();
    }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static int getNotificationCount(Module module, ScarabUser user) throws TorqueException
    {
        return NotificationStatusManager.getNotificationCount(module, user);
    }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
public static boolean wantEdit(ScarabUser user, Issue issue, RunData data) throws TorqueException
    {
        Object testExists = data.getParameters().get("edit_attributes");
        if(testExists != null)
        {
            boolean wantToOpenEditor = data.getParameters().getBoolean("edit_attributes");
            return wantToOpenEditor;
        }

        // Now check for condition
        String behaviour = GlobalParameterManager.getStringFromHierarchy(
                                                  "scarab.edit.behaviour",
                                                  issue.getModule(),
                                                  "default");
        if(behaviour.equals("smart"))
        {
            if(issue.isSealed())
            {
                return false; // don't open this issue in edit mode, because it is sealed!
            }
            // Check if user is assigned to issue.
            // If that is the case, open the issue
            // in edit mode per default.
            List<AttributeValue> userAttributeValues = issue.getUserAttributeValues(user);
            Iterator<AttributeValue> iter = userAttributeValues.iterator();
            while(iter.hasNext())
            {
                AttributeValue attributeValue = iter.next();
                Attribute attribute = attributeValue.getAttribute();
                String permission = attribute.getPermission();
                if("Issue | Edit".equals(permission))
                {
                    return true; // if can edit and want edit, lets edit ...
                }
            }
        }
        else
        {
            // Scarab default behaviour: Open issue in view mode.
        }
        return false;
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public String getRequiredModifyPermission(Issue issue) throws TorqueException
    {        
        String editPermission = ScarabSecurity.ISSUE__EDIT;
        
        String status = getTurbineProperty("scarab.common.status.id");
        if (status != null)
        {
            String value = getTurbineProperty("scarab.common.status.sealed");
            if(value != null)
            {
                AttributeValue attval = issue.getAttributeValue(status);
                if(attval != null && attval.getValue().equals(value))
                {
                    String permissionString = getTurbineProperty("scarab.common.status.sealed.modifyPermission");
                    if(permissionString != null)
                    {
                        editPermission = permissionString;
                    }
                }
            }
        }
        return editPermission;
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getCustomization(Object moduleId, Object userId, Object activityCode) throws TorqueException
    {
        NotificationRulePeer nfp = new NotificationRulePeer();
        List result = nfp.getCustomization(moduleId, userId, activityCode);
        return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public static Notification getEmptyNotificationFor(ScarabUser user, ScarabModule module) throws TorqueException
    {
        return new Notification(user, module);
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public static NotificationRule getNotificationRule(Integer ruleId) throws TorqueException
    {
        NotificationRule result = NotificationRuleManager.getInstance(ruleId);
        return result;
    }
            
// in java/org/tigris/scarab/tools/ScarabGlobalTool.java
public List getModulesFromIssueList(List issues)
        throws TorqueException
    {
        return ModuleManager.getInstancesFromIssueList(issues);
    }
            
// in java/org/tigris/scarab/search/CachedQuery.java
private static List executeSelect( String sql )
        throws TorqueException
    {
		List result;
		try 
    	{
	        long queryStartTime = System.currentTimeMillis();

		    result = BasePeer.executeQuery(sql);
	        
	        logLongRunningQuery(sql, System.currentTimeMillis() - queryStartTime);
        }
	    catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
        return result;
    }
            
// in java/org/tigris/scarab/attribute/SelectOneAttribute.java
public void init() throws TorqueException
    {
        /*
        if (getAttributeValue() == null &&
             !getScarabIssue().isNew()) 
        {
            Criteria crit = new Criteria()
                .add(ScarabIssueAttributeValuePeer.ATTRIBUTE_ID, 
                     getScarabAttribute().getPrimaryKey());
            
            Vector results = getScarabIssue()
                .getScarabIssueAttributeValues(crit); 
            if (results.size() == 1) // if value is not found it will be null until
            {
                setScarabIssueAttributeValue(
                    (ScarabIssueAttributeValue)results.get(0));
            }
        }
        if (getScarabIssueAttributeValue() != null)
        {
            value = getOptionById(
                getScarabIssueAttributeValue().getOptionId());
            loaded = true;
        }
        */
    }
            
// in java/org/tigris/scarab/attribute/OptionAttribute.java
public void setOption(final RModuleOption option)
        throws TorqueException
    {
        setOptionIdOnly(option.getOptionId());
        setValueOnly(option.getDisplayValue());
    }
            
// in java/org/tigris/scarab/attribute/OptionAttribute.java
public Object loadResources() throws TorqueException
    {
        return null;
    }
            
// in java/org/tigris/scarab/attribute/FreeFormAttribute.java
public void init() throws TorqueException
    {
        
        if (getIssue().isNew()) 
        {
            setDeleted(false);                
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setChainedValue(final AttributeValue  v)
        throws TorqueException, ScarabException
    {
        if (v == null)
        {
            this.chainedValue = null;
        }
        else 
        {        
            if (v.getAttributeId() == null && getAttributeId() != null) 
            {
                v.setAttributeId(getAttributeId());
            }
            else if (v.getAttribute() != null 
                     && !v.getAttribute().equals(getAttribute()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainAttributeValues,
                                          v.getAttributeId(),
                                          getAttributeId());
            }
            
            if (v.getIssueId() == null && getIssueId() != null) 
            {
                v.setIssueId(getIssueId());
            }
            else if (v.getIssue() != null 
                      && !v.getIssue().equals(getIssue()))
            {
                throw new ScarabException(L10NKeySet.ExceptionCantChainIssues,
                                          v.getIssueId(),
                                          getIssueId());
            }

            if (this.chainedValue == null) 
            {
                this.chainedValue = v;
            }
            else 
            {
                chainedValue.setChainedValue(v);
            }
            
            if (activitySet != null) 
            {
                v.startActivitySet(activitySet);
            }        
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setAttributeId(Integer nk)
        throws TorqueException
    {
        super.setAttributeId(nk);
        if (chainedValue != null) 
        {
            chainedValue.setAttributeId(nk);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setIssueId(Long nk)
        throws TorqueException
    {
        super.setIssueId(nk);
        if (chainedValue != null) 
        {
            chainedValue.setIssueId(nk);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void startActivitySet(ActivitySet activitySet)
        throws ScarabException, TorqueException
    {
        if (activitySet == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionCanNotStartActivitySet);
        }
        
        if (this.activitySet == null) 
        {
            this.activitySet = activitySet;
        }
        else
        {
            throw new ScarabException(L10NKeySet.ExceptionActivitySetInProgress);
        }
/*
This is wrong. It prevented the old/new value stuff from working properly!
If we have an existing issue and we change some attributes, then when the
history was created, the data was not valid in it for some reason. I'm not
quite sure why this was added. (JSS)

Leaving here so that John can remove or fix.

        oldOptionIdIsSet = false;
        oldValueIsSet = false;
        oldOptionId = null;
        oldValue = null;
*/

        // Check for previous active activities on this attribute 
        // If they exist, set old value for this activity
        List result = null;
        final Issue issue = getIssue();
        if (issue != null)
        {
            result = issue
                .getActivitiesWithNullEndDate(getAttribute());
        }
        if (result != null && result.size() > 0)
        {
            for (int i=0; i<result.size(); i++)
            {
                final Activity a = (Activity)result.get(i);
                oldOptionId = a.getNewOptionId();
                oldValue = a.getNewValue();
            }
        }
        if (chainedValue != null) 
        {
            chainedValue.startActivitySet(activitySet);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setOptionId(Integer optionId)
        throws TorqueException
    {
        if ( optionId != null ) 
        {
            Module module = getIssue().getModule();
            IssueType issueType = getIssue().getIssueType();
            if (module == null || issueType == null)
            {
                AttributeOption option = AttributeOptionManager
                    .getInstance(optionId);
                setValueOnly(option.getName());
            }
            else 
            {
                // FIXME! create a key and get the instance directly from
                // the manager.
                List options = null;

                options = module
                        .getRModuleOptions(getAttribute(), issueType);
                if(options != null)
                {
                    for (int i = options.size() - 1; i >= 0; i--)
                    {
                        RModuleOption option = (RModuleOption) options.get(i);
                        if (option.getOptionId().equals(optionId))
                        {
                            setValueOnly(option.getDisplayValue());
                            break;
                        }
                    }
                }
            }            
        }
        else
        {
            // any reason to set a option_id to null, once its already set?
            setValueOnly(null);
        }
        
        setOptionIdOnly(optionId);
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
protected void setOptionIdOnly(Integer optionId)
        throws TorqueException
    {
        if (!ObjectUtils.equals(optionId, getOptionId()))
        { 
            // if the value is set multiple times before saving only
            // save the last saved value
            if (!isNew() && !oldOptionIdIsSet && getOptionId() != null) 
            {
                oldOptionId = getOptionId();
                oldOptionIdIsSet = true;
            }
            super.setOptionId(optionId);
        }  
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setUserId(Integer userId)
        throws TorqueException
    {
        if (userId != null) 
        {
            ScarabUser user = ScarabUserManager.getInstance(userId);
            setValueOnly(user.getUserName());
        }
        else
        {
            // any reason to set a user_id to null, once its already set?
            setValueOnly(null);
        }

        setUserIdOnly(userId);
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
protected void setUserIdOnly(Integer value)
        throws TorqueException
    {
        if (!ObjectUtils.equals(value, getUserId()))
        { 
            // if the value is set multiple times before saving only
            // save the last saved value
            if (!isNew() && !oldUserIdIsSet) 
            {
                oldUserId = getUserId();
                oldUserIdIsSet = true;
            }
            super.setUserId(value);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setOptionIds(final Integer[] ids)
        throws TorqueException, ScarabException
    {
        if (ids != null && ids.length > 0) 
        {
            setOptionId(ids[0]);
        }
        if (ids != null && ids.length > 1) 
        {
            for (int i=1; i<ids.length; i++) 
            {            
                final AttributeValue av = AttributeValue                
                    .getNewInstance(getAttributeId(), getIssue());
                setChainedValue(av);
                av.setOptionId(ids[i]);
            }
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setUserIds(final Integer[] ids)
        throws TorqueException, ScarabException
    {
        if (ids != null && ids.length > 0) 
        {
            setUserId(ids[0]);
        }
        if (ids != null && ids.length > 1) 
        {
            for (int i=1; i<ids.length; i++) 
            {            
                final AttributeValue av = AttributeValue                
                    .getNewInstance(getAttributeId(), getIssue());
                setChainedValue(av);
                av.setUserId(ids[i]);
            }
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public boolean isRequired()
       throws TorqueException, ScarabException
    {
        return getRModuleAttribute().getRequired();
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public RModuleAttribute getRModuleAttribute()
        throws TorqueException, ScarabException
    {
        final Issue issue = getIssue();
        RModuleAttribute rma = null;
        if (issue != null)
        {
            final Module module = issue.getModule();
            if (module != null)
            {
                rma = module.getRModuleAttribute(
                    getAttribute(), getIssue().getIssueType());
            }
            else
            {
                throw new ScarabException (L10NKeySet.ExceptionGeneral,
                        "Module is null: Please report this issue."); //EXCEPTION
            }
        }
        else
        {
            throw new ScarabException (L10NKeySet.ExceptionGeneral,
                    "Issue is null: Please report this issue."); //EXCEPTION
        }
        return rma;
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public String getDisplayValue(ScarabLocalizationTool l10n)
    throws TorqueException
    {
        String displayValue = null;

        if(getAttribute().isOptionAttribute())
        {
            try
            {
                displayValue = getIssue().getModule().getRModuleOption( getAttributeOption(), getIssue().getIssueType()).getDisplayValue();
                //displayValue = getRModuleAttribute().getDisplayValue();
            }
            catch (NullPointerException npe)
            {
                // Something wrong in the database ?
                displayValue="";
            }
        }
        else if(getAttribute().isUserAttribute())
        {
            displayValue = getScarabUser().getUserName();
        }
		else if(getAttribute().isDateAttribute())
		{
			displayValue = DateAttribute.dateFormat(getValue(), L10NKeySet.ShortDateDisplay.getMessage(l10n));
		}
        else
        {
            displayValue = getValue();
        }
        return displayValue;
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public AttributeOption getAttributeOption()
        throws TorqueException
    {
        return getAttribute()
            .getAttributeOption(getOptionId());
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public boolean isQuickSearchAttribute()
        throws TorqueException
    {
        boolean result = false;
        List qsAttributes = getIssue().getIssueType()
            .getQuickSearchAttributes(getIssue().getModule());
        for (int i=qsAttributes.size()-1; i>=0; i--) 
        {
            if (((Attribute)qsAttributes.get(i)).equals(getAttribute())) 
            {
                result = true;
                break;
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public static AttributeValue getNewInstance(
        RModuleAttribute rma, Issue issue) throws TorqueException
    {
        return getNewInstance(rma.getAttributeId(), issue);
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public static AttributeValue getNewInstance(
        Integer attId, Issue issue) throws TorqueException
    {
        Attribute attribute = AttributeManager.getInstance(attId);
        return getNewInstance(attribute, issue);
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public static synchronized AttributeValue getNewInstance(
        Attribute attribute, Issue issue) throws TorqueException
    {
        AttributeValue attv = null;
        try
        {
            String className = attribute
                .getAttributeType().getJavaClassName();
            attv = (AttributeValue)
                Class.forName(className).newInstance();
            attv.setAttribute(attribute);
            attv.setIssue(issue);
    
            attv.init();
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        return attv;
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public AttributeValue copy() throws TorqueException
    {
        AttributeValue copyObj = AttributeValue
            .getNewInstance(getAttributeId(), getIssue());
        return copyInto(copyObj);
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public AttributeValue copy(Connection con) throws TorqueException 
    {
        throw new RuntimeException("Unimplemented method AttributeValue:copy(Connection conn)");
        //return copy();
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void save(Connection dbcon)
        throws TorqueException
    {
        if (isModified() && !getAttribute().isUserAttribute())
        {
            try
            {
                checkActivitySet(L10NKeySet.ExceptionCanNotSaveAttributeValue);
            }
            catch (Exception e)
            {
                throw new TorqueException(e);
            }
            if (saveActivity == null)
            {            
                if (getDeleted())
                {
                    saveActivity = ActivityManager
                        .create(getIssue(), getAttribute(), activitySet, 
                                ActivityType.ATTRIBUTE_CHANGED, null, null, getNumericValue(), ScarabConstants.INTEGER_0,
                                getUserId(), null, getOptionId(), null, 
                                getValue(), null, dbcon);
                }
                else
                {
                    saveActivity = ActivityManager
                        .create(getIssue(), getAttribute(), activitySet, 
                                ActivityType.ATTRIBUTE_CHANGED, null, null, oldNumericValue, getNumericValue(),
                                oldUserId, getUserId(), oldOptionId, getOptionId(), 
                                oldValue, getValue(), dbcon);
                }
            }
        }
        super.save(dbcon);
        if (chainedValue != null) 
        {
            chainedValue.save(dbcon);
        }
        endActivitySet();
    }
            
// in java/org/tigris/scarab/om/AttributeValue.java
public void setProperties(final AttributeValue attVal1)
        throws TorqueException
    {
        setAttribute(attVal1.getAttribute());
        setIssue(attVal1.getIssue());
        setNumericValue(attVal1.getNumericValue());
        setOptionId(attVal1.getOptionId());
        setUserId(attVal1.getUserId());
        setValue(attVal1.getValue());
    }
            
// in java/org/tigris/scarab/om/RIssueTypeAttribute.java
public void setIsDefaultText(boolean b)
        throws TorqueException
    {
        if (b && !getDefaultTextFlag()) 
        {
            // get related RIAs
            List rias = getIssueType().getRIssueTypeAttributes(false);
            
            // make sure no other rma is selected
            for (int i=0; i<rias.size(); i++) 
            {
                RIssueTypeAttribute ria = (RIssueTypeAttribute)rias.get(i);
                if (ria.getDefaultTextFlag()) 
                {
                    ria.setDefaultTextFlag(false);
                    ria.save();
                    break;
                }
            }
        }
        setDefaultTextFlag(b);
    }
            
// in java/org/tigris/scarab/om/RIssueTypeAttribute.java
public boolean getIsDefaultText()
        throws TorqueException
    {
        boolean isDefault = getDefaultTextFlag();
        if (!isDefault && getAttribute().isTextAttribute()) 
        {
            // get related RIAs
            List rias = getIssueType().getRIssueTypeAttributes();
            
            // check if another is chosen
            boolean anotherIsDefault = false;
            for (int i=0; i<rias.size(); i++) 
            {
                RIssueTypeAttribute ria = (RIssueTypeAttribute)rias.get(i);
                if (ria.getDefaultTextFlag()) 
                {
                    anotherIsDefault = true;
                    break;
                }
            }
            
            if (!anotherIsDefault) 
            {
                // locate the default text attribute
                for (int i=0; i<rias.size(); i++) 
                {
                    RIssueTypeAttribute ria = (RIssueTypeAttribute)rias.get(i);
                    if (ria.getAttribute().isTextAttribute()) 
                    {
                        if (ria.getAttributeId().equals(getAttributeId())) 
                        {
                            isDefault = true;
                        }
                        else 
                        {
                            anotherIsDefault = true;
                        }
                        
                        break;
                    }
                }
            }            
        }
        return isDefault;
    }
            
// in java/org/tigris/scarab/om/RIssueTypeAttribute.java
public void delete()
         throws TorqueException
    {
        if (Log.get().isDebugEnabled()) 
        {
            Log.get().debug(
                "Deleting SCARAB_R_ISSUETYPE_ATTRIBUTE where issuetype id=" 
                + getIssueTypeId() + " and attribute id=" + getAttributeId());
        }        
        Criteria c = new Criteria()
            .add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
            .add(RIssueTypeAttributePeer.ATTRIBUTE_ID, getAttributeId());
        RIssueTypeAttributePeer.doDelete(c);
        Attribute attr = getAttribute();
        String attributeType = null;
        attributeType = (attr.isUserAttribute() ? IssueType.USER : IssueType.NON_USER);
        getIssueType().getRIssueTypeAttributes(false, attributeType).remove(this);

        // delete issuetype-option mappings
        if (attr.isOptionAttribute())
        {
            List optionList = getIssueType().getRIssueTypeOptions(attr, false);
            if (optionList != null && !optionList.isEmpty()) 
            {            
                ArrayList optionIdList = new ArrayList(optionList.size());
                for (int i =0; i<optionList.size(); i++)
                { 
                    optionIdList.add(((RIssueTypeOption)optionList.get(i)).getOptionId());
                }
                Criteria c2 = new Criteria()
                    .add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId())
                    .addIn(RIssueTypeOptionPeer.OPTION_ID, optionIdList);
                RIssueTypeOptionPeer.doDelete(c2);
            }
        }
    }
            
// in java/org/tigris/scarab/om/RIssueTypeAttribute.java
public RIssueTypeAttribute copyRia()
         throws TorqueException
    {                
        RIssueTypeAttribute ria = new RIssueTypeAttribute(); 
        ria.setIssueTypeId(getIssueTypeId());
        ria.setAttributeId(getAttributeId());
        ria.setActive(getActive());
        ria.setRequired(getRequired());
        ria.setOrder(getOrder());
        ria.setQuickSearch(getQuickSearch());
        ria.setDefaultTextFlag(getDefaultTextFlag());
        return ria;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public MITList copy() throws TorqueException
    {
        MITList copyObj = new MITList();
        copyObj.setName(getName());
        copyObj.setActive(getActive());
        copyObj.setModifiable(getModifiable());
        copyObj.setUserId(getUserId());

        List v = getMITListItems();
        for (int i = 0; i < v.size(); i++)
        {
            MITListItem obj = (MITListItem) v.get(i);
            copyObj.addMITListItem(obj.copy());
        }

        return copyObj;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public MITList getPermittedSublist(String permission, ScarabUser user)
        throws TorqueException
    {
        String[] perms = { permission };
        return getPermittedSublist(perms, user);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public MITList getPermittedSublist(String[] permissions, ScarabUser user)
        throws TorqueException
    {
        MITList sublist = new MITList();
        ScarabUser userB = getScarabUser();
        if (userB != null)
        {
            sublist.setScarabUser(userB);
        }
        List items = getExpandedMITListItems();
        sublist.isAllMITs = this.isAllMITs;
        Module[] validModules = user.getModules(permissions);

        Set moduleIds = new HashSet();
        for (int j = 0; j < validModules.length; j++)
        {
            moduleIds.add(validModules[j].getModuleId());
        }

        for (Iterator i = items.iterator(); i.hasNext();)
        {
            MITListItem item = (MITListItem) i.next();
            if (moduleIds.contains(item.getModuleId()))
            {
                // use a copy of the item here to avoid changing the the
                // list_id of the original
                sublist.addMITListItem(item.copy());
            }
        }

        return sublist;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public Module getModule() throws TorqueException
    {
        if (!isSingleModule())
        {
            throw new IllegalStateException(
                "method should not be called on"
                    + " a list including more than one module."); //EXCEPTION
        }
        return getModule(getFirstItem());
    }
            
// in java/org/tigris/scarab/om/MITList.java
public IssueType getIssueType() throws TorqueException
    {
        if (!isSingleIssueType())
        {
            throw new IllegalStateException(
                "method should not be called on"
                    + " a list including more than one issue type."); //EXCEPTION
        }
        return getFirstItem().getIssueType();
    }
            
// in java/org/tigris/scarab/om/MITList.java
Module getModule(MITListItem item) throws TorqueException
    {
        Module module = null;
        if (item.getModuleId() == null)
        {
            ScarabUser user = getScarabUser();
            module = user.getCurrentModule();
        }
        else
        {
            module = item.getModule();
        }
        return module;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public void setScarabUser(ScarabUser v) throws TorqueException
    {
        if (v == null)
        {
            throw new IllegalArgumentException("cannot set user to null."); //EXCEPTION
        }

        super.setScarabUser(v);
        aScarabUser = v;
        expandedList = null;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public ScarabUser getScarabUser() throws TorqueException
    {
        ScarabUser user = null;
        if (aScarabUser == null)
        {
            user = super.getScarabUser();
        }
        else
        {
            user = aScarabUser;
        }
        return user;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getAttributes(final boolean activeOnly, final boolean commonOnly)
            throws TorqueException,
            DataSetException
    {

        Set matchingAttributes = new HashSet();
        Iterator iter = iterator();
        while (iter.hasNext())
        {
            final MITListItem item = (MITListItem)iter.next();
            final List rmas = getModule(item).getRModuleAttributes(
                    item.getIssueType());
            for (Iterator i = rmas.iterator(); i.hasNext();)
            {
                final RModuleAttribute rma = (RModuleAttribute) i.next();
                final Attribute att = rma.getAttribute();
                if ((!activeOnly || rma.getActive()))
                {
                    boolean wantedAttribute = (commonOnly) ? isCommon(att,
                            activeOnly) : true;
                    if (size() == 1 || wantedAttribute)
                    {
                        matchingAttributes.add(att);
                    }
                }
            }
            if(commonOnly)
            {
                // don't need to iterate through other Items, because the
                // intersection with the first MITListItem is sufficient
                // to fulfill the commonOnly rule.
                break;
            }
        }

        // Finally copy the resultset into an ArrayList for
        // compatibility to older implementaiton of this method.
        final List result = new ArrayList();
        iter = matchingAttributes.iterator();
        while(iter.hasNext())
        {
            result.add(iter.next());
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonAttributes() throws TorqueException, DataSetException
    {
        return getAttributes(true,true);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonAttributes(final boolean activeOnly) throws TorqueException, DataSetException
    {
        return getAttributes(activeOnly, true);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final Attribute attribute, final boolean activeOnly)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        addToCriteria(
            crit,
            RModuleAttributePeer.MODULE_ID,
            RModuleAttributePeer.ISSUE_TYPE_ID);
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID, attribute.getAttributeId());
        if (activeOnly)
        {
            crit.add(RModuleAttributePeer.ACTIVE, true);
        }

        return size() == RModuleAttributePeer.count(crit);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final Attribute attribute) throws TorqueException, DataSetException
    {
        return isCommon(attribute, true);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonNonUserAttributes() throws TorqueException, DataSetException
    {
        assertNotEmpty();

        final List matchingAttributes = new ArrayList();
        final MITListItem item = getFirstItem();

        final List rmas = getModule(item).getRModuleAttributes(item.getIssueType());
        final Iterator i = rmas.iterator();
        while (i.hasNext())
        {
            final RModuleAttribute rma = (RModuleAttribute) i.next();
            final Attribute att = rma.getAttribute();
            if (!att.isUserAttribute() && rma.getActive() && isCommon(att))
            {
                matchingAttributes.add(att);
            }
        }

        return matchingAttributes;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonOptionAttributes() throws TorqueException, DataSetException
    {
        assertNotEmpty();

        final List matchingAttributes = new ArrayList();
        final MITListItem item = getFirstItem();

        final List rmas = getModule(item).getRModuleAttributes(item.getIssueType());
        final Iterator i = rmas.iterator();
        while (i.hasNext())
        {
            final RModuleAttribute rma = (RModuleAttribute) i.next();
            final Attribute att = rma.getAttribute();
            if (att.isOptionAttribute() && rma.getActive() && isCommon(att))
            {
                matchingAttributes.add(att);
            }
        }

        return matchingAttributes;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<Attribute> getCommonUserAttributes(final boolean activeOnly) 
        throws TorqueException, DataSetException
    {
        List<Attribute> attributes = null;
        if (isSingleModuleIssueType())
        {
            attributes =
                getModule().getUserAttributes(getIssueType(), activeOnly);
        }
        else
        {
            final List<Attribute> matchingAttributes = new ArrayList<Attribute>();
            final MITListItem item = getFirstItem();
            final List<RModuleAttribute> rmas =
                getModule(item).getRModuleAttributes(
                    item.getIssueType(),
                    activeOnly,
                    Module.USER);
            final Iterator<RModuleAttribute> i = rmas.iterator();
            while (i.hasNext())
            {
                final RModuleAttribute rma = i.next();
                final Attribute att = rma.getAttribute();
                if ((!activeOnly || rma.getActive())
                    && isCommon(att, activeOnly))
                {
                    matchingAttributes.add(att);
                }
            }
            attributes = matchingAttributes;
        }
        return attributes;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<Attribute> getCommonUserAttributes() throws TorqueException, DataSetException
    {
        return getCommonUserAttributes(false);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<ScarabUser> getPotentialAssignees(boolean includeCommitters)
        throws TorqueException, DataSetException
    {
        List<ScarabUser> users = new ArrayList<ScarabUser>();
        List<String> perms = getUserAttributePermissions();
        if (includeCommitters && !perms.contains(ScarabSecurity.ISSUE__ENTER))
        {
            perms.add(ScarabSecurity.ISSUE__ENTER);
        }
        if (isSingleModule())
        {
            ScarabUser[] userArray = getModule().getUsers(perms);
            for (int i = 0; i < userArray.length; i++)
            {
                users.add(userArray[i]);
            }
        }
        else
        {
            MITListItem item = getFirstItem();
            ScarabUser[] userArray = getModule(item).getUsers(perms);
            List<Module> modules = getModules();
            for (int i = 0; i < userArray.length; i++)
            {
                boolean validUser = false;
                ScarabUser user = userArray[i];
                for (Iterator<String> j = perms.iterator(); j.hasNext() && !validUser;)
                {
                    validUser = user.hasPermission(j.next(), modules);
                }
                if (validUser)
                {
                    users.add(user);
                }
            }
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<String> getUserAttributePermissions() throws TorqueException, DataSetException
    {
        final List userAttrs = getCommonUserAttributes();
        final List<String> permissions = new ArrayList<String>();
        for (int i = 0; i < userAttrs.size(); i++)
        {
            final String permission = ((Attribute) userAttrs.get(i)).getPermission();
            if (!permissions.contains(permission))
            {
                permissions.add(permission);
            }
        }
        return permissions;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getAllRModuleUserAttributes() 
    throws TorqueException, DataSetException, TurbineSecurityException
    {
        List rmuas = getSavedRMUAs();
        return rmuas;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleUserAttributes() 
        throws TorqueException, DataSetException, TurbineSecurityException
    {
        final List matchingRMUAs = new ArrayList();
        List rmuas = getSavedRMUAs();
        Iterator i = rmuas.iterator();
        final ScarabUser user = getScarabUser();
        while (i.hasNext())
        {
            final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
            final Attribute att = rmua.getAttribute();
            if (isCommon(att, false))
            {
                matchingRMUAs.add(rmua);
            }
        }

        // None of the saved RMUAs are common for these pairs
        // Delete them and seek new ones.
        if (matchingRMUAs.isEmpty())
        {
            i = rmuas.iterator();
            while (i.hasNext())
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                rmua.delete(user);
            }
            final int sizeGoal = 3;
            int moreAttributes = sizeGoal;

            // First try saved RMUAs for first module-issuetype pair
            final MITListItem item = getFirstItem();
            final Module module = getModule(item);
            final IssueType issueType = item.getIssueType();
            rmuas = user.getRModuleUserAttributes(module, issueType);
            // Next try default RMUAs for first module-issuetype pair
            if (rmuas.isEmpty())
            {
                rmuas = module.getDefaultRModuleUserAttributes(issueType);
            }

            // Loop through these and if find common ones, save the RMUAs
            i = rmuas.iterator();
            while (i.hasNext() && moreAttributes > 0)
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                final Attribute att = rmua.getAttribute();
                if (isCommon(att, false) && !matchingRMUAs.contains(rmua))
                {
                    final RModuleUserAttribute newRmua =
                        getNewRModuleUserAttribute(att);
                    newRmua.setOrder(1);
                    newRmua.save();
                    matchingRMUAs.add(rmua);
                    moreAttributes--;
                }
            }

            // if nothing better, go with random common attributes
            moreAttributes = sizeGoal - matchingRMUAs.size();
            if (moreAttributes > 0)
            {
                Iterator attributes = getCommonAttributes(false).iterator();
                int k = 1;
                while (attributes.hasNext() && moreAttributes > 0)
                {
                    Attribute att = (Attribute) attributes.next();
                    boolean isInList = false;
                    i = matchingRMUAs.iterator();
                    while (i.hasNext())
                    {
                        RModuleUserAttribute rmua =
                            (RModuleUserAttribute) i.next();
                        if (rmua.getAttribute().equals(att))
                        {
                            isInList = true;
                            break;
                        }
                    }
                    if (!isInList)
                    {
                        RModuleUserAttribute rmua =
                            getNewRModuleUserAttribute(att);
                        rmua.setOrder(k++);
                        rmua.save();
                        matchingRMUAs.add(rmua);
                        moreAttributes--;
                    }
                }
            }
        }

        return matchingRMUAs;
    }
            
// in java/org/tigris/scarab/om/MITList.java
protected RModuleUserAttribute getNewRModuleUserAttribute(Attribute attribute)
        throws TorqueException
    {
        RModuleUserAttribute result = RModuleUserAttributeManager.getInstance();
        result.setUserId(getUserId());
        result.setAttributeId(attribute.getAttributeId());

        if (isSingleModuleIssueType())
        {
            result.setModuleId(getModule().getModuleId());
            result.setIssueTypeId(getIssueType().getIssueTypeId());
        }

        if (!isNew())
        {
            result.setListId(getListId());
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/MITList.java
private List getMatchingRMOs(List rmos) throws TorqueException, Exception
    {
        List matchingRMOs = new ArrayList();
        if (rmos != null)
        {
            for (Iterator i = rmos.iterator(); i.hasNext();)
            {
                RModuleOption rmo = (RModuleOption) i.next();
                AttributeOption option = rmo.getAttributeOption();
                if (rmo.getActive() && isCommon(option))
                {
                    matchingRMOs.add(rmo);
                }
            }
        }
        return matchingRMOs;
    }
            
// in java/org/tigris/scarab/om/MITList.java
protected List getSavedRMUAs() throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RModuleUserAttributePeer.USER_ID, getUserId());
        if (!isNew())
        {
            Long listId = getListId();
            crit.add(RModuleUserAttributePeer.LIST_ID, listId);
        }
        else
        {
            Integer moduleId    = null;
            Integer issueTypeId = null;
            
            if(isSingleModuleIssueType())
            {
                Module module = getModule();
                moduleId     = module.getModuleId();
               
                IssueType issueType = getIssueType();
                issueTypeId   = issueType.getIssueTypeId();
            }
            else if (isSingleModule())
            {
                moduleId    = getModule().getModuleId();
            }
            else if (isSingleIssueType())
            {
                IssueType issueType = getIssueType();
                issueTypeId   = issueType.getIssueTypeId();
            }
            
            crit.add(RModuleUserAttributePeer.LIST_ID,       null);
            crit.add(RModuleUserAttributePeer.MODULE_ID,     moduleId);
            crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, issueTypeId);
        }

        crit.addAscendingOrderByColumn(
            RModuleUserAttributePeer.PREFERRED_ORDER);

        return RModuleUserAttributePeer.doSelect(crit);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonLeafRModuleOptions(final Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getLeafRModuleOptions(
                attribute,
                item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }
        catch(Exception e)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleOptionTree(Attribute attribute)
        throws TorqueException, ScarabException
    {
        assertNotEmpty();
        final MITListItem item = getFirstItem();
        final List rmos =
            getModule(item).getOptionTree(attribute, item.getIssueType());
        try
        {
            return getMatchingRMOs(rmos);
        }  
        catch (Exception ex)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getAllRModuleOptionTree(Attribute attribute)
        throws TorqueException
    {
        assertNotEmpty();
    
        // Get all isse types from this MITList
        List listItems = getExpandedMITListItems();

        // Get all attribute options from all issue types for the requested attribute
        List attributeOptions = new ArrayList();
        if (listItems!=null) {
            Iterator listItemIterator = listItems.iterator();
            while (listItemIterator.hasNext()) {
                MITListItem item = (MITListItem)listItemIterator.next();
                List rmos = getModule(item).getOptionTree(attribute, item.getIssueType());
                mergeRModuleOptionsIgnoreDuplicates(attributeOptions, rmos);
            }
        }
    
        return attributeOptions;
    }
            
// in java/org/tigris/scarab/om/MITList.java
private void mergeRModuleOptionsIgnoreDuplicates(List masterList, List addList)
        throws TorqueException {
        // Get a set of all existing option ids
        Set optionIds = new HashSet();
        Iterator masterIterator = masterList.iterator();
        while (masterIterator.hasNext()) {
            RModuleOption option = (RModuleOption)masterIterator.next();
            optionIds.add(option.getOptionId());
        }
  
        // add all options not already present in the list, add only active options
        Iterator addIterator = addList.iterator();
        while (addIterator.hasNext()) {
            RModuleOption rmo = (RModuleOption)addIterator.next();
            if (rmo.getActive() && !optionIds.contains(rmo.getOptionId())) {
                masterList.add(rmo);
            }
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getDescendantsUnion(AttributeOption option) throws TorqueException
    {
        assertNotEmpty();

        List matchingRMOs = new ArrayList();
        Iterator items = iterator();
        while (items.hasNext())
        {
            MITListItem item = (MITListItem) items.next();
            IssueType issueType = item.getIssueType();
            RModuleOption parent =
                getModule(item).getRModuleOption(option, issueType);
            if (parent != null)
            {
                Iterator i = parent.getDescendants(issueType).iterator();
                while (i.hasNext())
                {
                    RModuleOption rmo = (RModuleOption) i.next();
                    if (!matchingRMOs.contains(rmo))
                    {
                        matchingRMOs.add(rmo);
                    }
                }
            }
        }

        return matchingRMOs;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final AttributeOption option) throws TorqueException, DataSetException
    {
        return isCommon(option, true);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public boolean isCommon(final AttributeOption option, final boolean activeOnly)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        addToCriteria(
            crit,
            RModuleOptionPeer.MODULE_ID,
            RModuleOptionPeer.ISSUE_TYPE_ID);
        crit.add(RModuleOptionPeer.OPTION_ID, option.getOptionId());
        if (activeOnly)
        {
            crit.add(RModuleOptionPeer.ACTIVE, true);
        }

        return size() == RModuleOptionPeer.count(crit);
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List<Module> getModules() throws TorqueException
    {
        assertNotEmpty();

        List items = getExpandedMITListItems();
        ArrayList modules = new ArrayList(items.size());
        Iterator<MITListItem> i = items.iterator();
        while (i.hasNext())
        {
            Module m = i.next().getModule();
            if (!modules.contains(m))
            {
                modules.add(m);
            }
        }
        return modules;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public void addToCriteria(Criteria crit) throws TorqueException
    {
        addToCriteria(crit, IssuePeer.MODULE_ID, IssuePeer.TYPE_ID);
    }
            
// in java/org/tigris/scarab/om/MITList.java
private void addToCriteria(
        Criteria crit,
        String moduleField,
        String issueTypeField)
        throws TorqueException
    {
        if (!isSingleModule() && isSingleIssueType())
        {
            crit.addIn(moduleField, getModuleIds());
            crit.add(issueTypeField, getIssueType().getIssueTypeId());
        }
        else if (isSingleModule() && !isSingleIssueType())
        {
            crit.add(moduleField, getModule().getModuleId());
            crit.addIn(issueTypeField, getIssueTypeIds());
        }
        else if (isAllMITs)
        {
            crit.addIn(moduleField, getModuleIds());
            // we do this to avoid including templates in results
            crit.addIn(issueTypeField, getIssueTypeIds());
        }
        else if (size() > 0)
        {
            List items = getExpandedMITListItems();
            Iterator i = items.iterator();
            Criteria.Criterion c = null;
            while (i.hasNext())
            {
                MITListItem item = (MITListItem) i.next();
                Criteria.Criterion c1 =
                    crit.getNewCriterion(
                        moduleField,
                        item.getModuleId(),
                        Criteria.EQUAL);
                Criteria.Criterion c2 =
                    crit.getNewCriterion(
                        issueTypeField,
                        item.getIssueTypeId(),
                        Criteria.EQUAL);
                c1.and(c2);
                if (c == null)
                {
                    c = c1;
                }
                else
                {
                    c.or(c1);
                }
            }
            crit.add(c);
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public void addAll(MITList list) throws TorqueException
    {
        List currentList = getExpandedMITListItems();
        for (Iterator i = list.getExpandedMITListItems().iterator();
            i.hasNext();
            )
        {
            MITListItem item = (MITListItem) i.next();
            if (!currentList.contains(item))
            {
                addMITListItem(item);
            }
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public void addMITListItem(MITListItem item) throws TorqueException
    {
        super.addMITListItem(item);
        expandedList = null;
        calculateIsAllMITs(item);
    }
            
// in java/org/tigris/scarab/om/MITList.java
private void addIssueTypes(Module module, List items) throws TorqueException
    {
        Iterator rmits = module.getRModuleIssueTypes().iterator();
        while (rmits.hasNext())
        {
            MITListItem newItem = MITListItemManager.getInstance();
            newItem.setModuleId(module.getModuleId());
            newItem.setIssueTypeId(
                ((RModuleIssueType) rmits.next()).getIssueTypeId());
            newItem.setListId(getListId());
            items.add(newItem);
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public void save(Connection con) throws TorqueException
    {
        super.save(con);
        if (itemsScheduledForDeletion != null
            && !itemsScheduledForDeletion.isEmpty())
        {
            List itemIds = new ArrayList(itemsScheduledForDeletion.size());
            for (Iterator iter = itemsScheduledForDeletion.iterator();
                iter.hasNext();
                )
            {
                MITListItem item = (MITListItem) iter.next();
                if (!item.isNew())
                {
                    itemIds.add(item.getItemId());
                }
            }
            if (!itemIds.isEmpty())
            {
                Criteria crit = new Criteria();
                crit.addIn(MITListItemPeer.ITEM_ID, itemIds);
                MITListItemPeer.doDelete(crit);
            }
        }
    }
            
// in java/org/tigris/scarab/om/MITList.java
public String getAttributeDisplayName(final Attribute attribute) 
        throws TorqueException
    {
        String displayName = null;
        for( MITListItem item : ((List<MITListItem>)getExpandedMITListItems()))
        {
            final String nameCandidate = item.getAttributeDisplayName(attribute);

            displayName = displayName == null ? nameCandidate : displayName;
            
            if(!displayName.equals(nameCandidate))
            {
                displayName = attribute.getName();
                break;
            }            
        }
        return displayName;
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        GlobalParameter gp = (GlobalParameter)om;
        Serializable moduleId = gp.getModuleId();
        String name = gp.getName();
        if (moduleId == null)
        {
            // if altering a global parameter, its possible the
            // module overrides are invalid.
            getMethodResult().removeAll(MANAGER_KEY, name);
        }
        else
        {
            getMethodResult().remove(MANAGER_KEY, name, GET_STRING,
                                     moduleId);
        }
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
private static GlobalParameter getInstance(String name)
        throws TorqueException
    {
        return getInstance(name, null);
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
private static GlobalParameter getInstance(String name, Module module)
        throws TorqueException
    {
        GlobalParameter result = null;
        Criteria crit = new Criteria();
        crit.add(GlobalParameterPeer.NAME, name);
        if (module == null)
        {
            crit.add(GlobalParameterPeer.MODULE_ID, null);
        }
        else
        {
            crit.add(GlobalParameterPeer.MODULE_ID, module.getModuleId());
        }
        List parameters = GlobalParameterPeer.doSelect(crit);
        if (!parameters.isEmpty())
        {
            result = (GlobalParameter)parameters.get(0);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
private static String getStringModule(String name, Module module )
        throws TorqueException
    {
        String value = (String) getMethodResult()
                .get(MANAGER_KEY, name, GET_STRING, module.getModuleId());

        if(value == null)
        {
            GlobalParameter p = getInstance(name, module);

            if (p != null)
            {
                value = p.getValue();
            }
            if(value==null)
            {
                value = "";
            }
            getMethodResult().put(value, MANAGER_KEY, name, GET_STRING, module.getModuleId());
        }
        return value;
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
private static String getStringGlobal(String name)
        throws TorqueException
    {
        String value = (String) getMethodResult()
                .get(MANAGER_KEY, name, GET_STRING );

        if(value == null)
        {
            GlobalParameter p = getInstance(name);

            if (p != null)
            {
                value = p.getValue();
            }
            if(value==null || value.equals(""))
            {
                value = Turbine.getConfiguration().getString(name);
            }
            if(value==null)
            {
                value = "";
            }
            getMethodResult().put(value, MANAGER_KEY, name, GET_STRING);
        }
        return value;
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static String getString(String name)
        throws TorqueException
    {
        return getStringGlobal(name);
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static String getString(String name, Module module)
        throws TorqueException
    {
        String value = getStringModule(name, module);
        if (value.equals(""))
        {
            value = getStringGlobal(name);
        }
        return value;
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static String getStringFromHierarchy(String name, Module module, String def)
        throws TorqueException
    {
      String value = getStringModule( name, module );

      if(value.equals(""))
      {
          Module parentModule = module.getParent();
         if(parentModule != null)
         {
             value = getStringFromHierarchy(name, parentModule, def);
         }
      }

        if(value.equals(""))
        {
            value = getStringGlobal(name);
        }

        if(value.equals(""))
        {
            value = def;
        }

        return value;
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static void setString(String name, String value)
        throws TorqueException
    {
      setString(name, null, value);
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static void setString(String name, Module module, String value)
        throws TorqueException
    {
        GlobalParameter p = getInstance(name, module);
        if (p == null)
        {
            p = getInstance();
            p.setName(name);
            p.setModuleId(module.getModuleId());
        }
        p.setValue(value);
        p.save();
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static boolean getBoolean(String name)
        throws TorqueException
    {
        return toBoolean(getString(name));
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static boolean getBoolean(String name, Module module)
        throws TorqueException
    {
        return toBoolean(getString(name, module));
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static boolean getBooleanFromHierarchy(String name, Module module, boolean def)
        throws TorqueException
    {
        String defAsString = (def)? "TRUE":"FALSE";
        return toBoolean(getStringFromHierarchy(name, module, defAsString ));
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static void setBoolean(String name, boolean value)
        throws TorqueException
    {
        setString(name, (value ? "TRUE" : "FALSE"));
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static void setBoolean(String name, Module module, boolean value)
        throws TorqueException
    {
        setString(name, module, (value ? "TRUE" : "FALSE"));
    }
            
// in java/org/tigris/scarab/om/GlobalParameterManager.java
public static List getStringList(String name)
        throws TorqueException
    {
        return toStringList(getString(name));
    }
            
// in java/org/tigris/scarab/om/Query.java
public ScarabUser getScarabUser() 
        throws TorqueException
    {
        ScarabUser user = this.scarabUser;
        if (user == null) 
        {
            user = super.getScarabUser();
        }
        
        return user;
    }
            
// in java/org/tigris/scarab/om/Query.java
public void setScarabUser(ScarabUser  v) 
        throws TorqueException
    {
        this.scarabUser = v;
        super.setScarabUser(v);
    }
            
// in java/org/tigris/scarab/om/Query.java
public void setModule(Module me)
        throws TorqueException
    {
        if (me == null) 
        {
            setModuleId((Integer)null);            
        }
        else 
        {
            Integer id = me.getModuleId();
            if (id == null) 
            {
                throw new TorqueException("Modules must be saved prior to " +
                    "being associated with other objects."); //EXCEPTION
            }
            setModuleId(id);
        }        
    }
            
// in java/org/tigris/scarab/om/Query.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
            
// in java/org/tigris/scarab/om/Query.java
public boolean canDelete(ScarabUser user)
        throws TorqueException
    {
        // can delete a query if they have delete permission
        // Or if is their personal query
        return (user.hasPermission(ScarabSecurity.ITEM__DELETE, getModule())
                || (user.getUserId().equals(getUserId()) 
                   && (getScopeId().equals(Scope.PERSONAL__PK))));
    }
            
// in java/org/tigris/scarab/om/Query.java
public boolean canEdit(ScarabUser user)
        throws TorqueException
    {
        return canDelete(user);
    }
            
// in java/org/tigris/scarab/om/Query.java
public boolean saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped query, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        Exception exception=null; // temporary store a thrown exception

        if (getScopeId().equals(Scope.PERSONAL__PK) 
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        }
        else
        {
            setApproved(false);

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");

                final ScarabUser[] toUsers = module
                    .getUsers(ScarabSecurity.ITEM__APPROVE);

                if (Log.get().isDebugEnabled()) 
                {
                    if (toUsers == null || toUsers.length ==0) 
                    {
                        Log.get().debug("No users to approve query.");    
                    }
                    else 
                    {
                        Log.get().debug("Users to approve query: ");    
                        for (int i=0; i<toUsers.length; i++) 
                        {
                            Log.get().debug(toUsers[i].getEmail());
                        }  
                    }          
                }
                
                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewQueryRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx,
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null,
                        template);
                }
                catch (Exception e)
                {
                    exception = e;
                }
            }
        }
        if (getMITList() != null) 
        {
            getMITList().save();
            // it would be good if this updated our list id, but it doesn't
            // happen automatically so reset it.
            setMITList(getMITList());            
        }
        save();
        if(exception != null)
        {
            throw new ScarabException(L10NKeySet.ExceptionGeneral, exception);
        }
        return true;
    }
            
// in java/org/tigris/scarab/om/Query.java
public MITList getMITList()
        throws TorqueException
    {
        MITList mitlist = super.getMITList();
        if (mitlist == null) 
        {
            mitlist = MITListManager.getSingleItemList(getModule(),
                getIssueType(), null);
        }
        return mitlist;
    }
            
// in java/org/tigris/scarab/om/Query.java
public void subscribe(ScarabUser user, Integer frequencyId)
        throws TorqueException
    {
        RQueryUser rqu = getRQueryUser(user);
        rqu.setSubscriptionFrequency(frequencyId);
        rqu.setIsSubscribed(true);
        rqu.save();
    }
            
// in java/org/tigris/scarab/om/Query.java
public void unSubscribe(ScarabUser user)
        throws TorqueException
    {
        RQueryUser rqu = getRQueryUser(user);
        if (rqu.getIsdefault())
        {
            rqu.setIsSubscribed(false);
            rqu.save();
        }
        else
        {
            rqu.delete(user);
        }
    }
            
// in java/org/tigris/scarab/om/Query.java
public RQueryUser getRQueryUser(ScarabUser user)
        throws TorqueException
    {
        RQueryUser result = null;
        Object obj = ScarabCache.get(this, GET_R_QUERY_USER, user); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(RQueryUserPeer.QUERY_ID, getQueryId());
            crit.add(RQueryUserPeer.USER_ID, user.getUserId());
            List rqus = RQueryUserPeer.doSelect(crit);
            if (!rqus.isEmpty())
            {
                result = (RQueryUser)rqus.get(0);
            }
            else
            {
                result = new RQueryUser();
                result.setQuery(this);
                result.setUserId(user.getUserId());
            }
            ScarabCache.put(result, this, GET_R_QUERY_USER, user);
        }
        else 
        {
            result = (RQueryUser)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Query.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/Query.java
public void delete(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module)
          || (user.getUserId().equals(getUserId()) 
             && getScopeId().equals(Scope.PERSONAL__PK)))
        {
            // Delete user-query maps.
            final List rqus = getRQueryUsers();
            for (int i=0; i<rqus.size(); i++)
            {
                final RQueryUser rqu = (RQueryUser)rqus.get(i);
                rqu.delete(user);
            }
            setDeleted(true);
            save();
            
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/Query.java
public void copyQuery(ScarabUser user)
         throws TorqueException
    {                
         Query newQuery = new Query();
         newQuery.setName(getName() + " (copy)");
         newQuery.setDescription(getDescription());
         newQuery.setValue(getValue());
         newQuery.setModuleId(getModuleId());
         newQuery.setIssueTypeId(getIssueTypeId());
         newQuery.setListId(getListId());
         newQuery.setApproved(getApproved());
         newQuery.setCreatedDate(new Date());
         newQuery.setUserId(user.getUserId());
         newQuery.setScopeId(getScopeId());
         newQuery.save();

         RQueryUser rqu = getRQueryUser(user);
         if (rqu != null)
         {
             RQueryUser rquNew = new RQueryUser();
             rquNew.setQueryId(newQuery.getQueryId());
             rquNew.setUserId(user.getUserId());
             rquNew.setSubscriptionFrequency(rqu.getSubscriptionFrequency());
             rquNew.setIsdefault(rqu.getIsdefault());
             rquNew.setIsSubscribed(rqu.getIsSubscribed());
             rquNew.save();
         }
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(ActivityPeer.ISSUE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity getInstance(String id)
        throws TorqueException
    {
        return getInstance(new Long(id));
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createNumericActivity(Issue issue, Attribute attribute,
                                                 ActivitySet activitySet, 
                                                 Attachment attachment,
                                                 Integer oldNumericValue,
                                                 Integer newNumericValue)
        throws TorqueException
    {
        return create(issue,attribute,activitySet,ActivityType.ATTRIBUTE_CHANGED,null,attachment,
                      oldNumericValue, newNumericValue,
                      null, null, null, null, null, null);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createUserActivity(Issue issue, Attribute attribute,
                                                 ActivitySet activitySet, 
                                                 Attachment attachment,
                                                 Integer oldUserId,
                                                 Integer newUserId)
        throws TorqueException
    {
        String oldUsername = null;
        String newUsername = null;
        if (oldUserId != null)
        {
            oldUsername = ScarabUserManager.getInstance(oldUserId).getUserName();
        }
        if (newUserId != null)
        {
            newUsername = ScarabUserManager.getInstance(newUserId).getUserName();
        }
        return create(issue,attribute,activitySet,ActivityType.USER_ATTRIBUTE_CHANGED,null,attachment,
                      null, null,
                      oldUserId, newUserId, 
                      null, null, oldUsername, newUsername);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createAddDependencyActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 Depend depend)
        throws TorqueException
    {
        return create(issue,null,activitySet,ActivityType.DEPENDENCY_CREATED,null,null,depend,
                      null, null,
                      null, null,
                      null, null,
                      null, depend.getDependType().getName(), null);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createChangeDependencyActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 Depend depend,
                                                 String oldTextValue,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,null,activitySet,ActivityType.DEPENDENCY_CHANGED,null,null,depend,
                      null, null,
                      null, null,
                      null, null,
                      oldTextValue, newTextValue, null);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createDeleteDependencyActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 Depend depend)
        throws TorqueException
    {
        return create(issue,null,activitySet,ActivityType.DEPENDENCY_DELETED,null,null,depend,
                      null, null,
                      null, null,
                      null, null,
                      depend.getDependType().getName(), null, null);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,null,activitySet,type,null,null,
                      null, null,
                      null, null,
                      null, null,
                      null, newTextValue);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 Attachment attachment)
        throws TorqueException
    {
        return create(issue,null,activitySet,type,null,attachment,
                      null, null,
                      null, null,
                      null, null,
                      null, null);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue, Attribute attribute,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 String oldTextValue,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,attribute,activitySet,type,null,null,
                      null, null,
                      null, null,
                      null, null,
                      oldTextValue, newTextValue);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 Attachment attachment, 
                                                 String oldTextValue,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,null,activitySet,type,null,attachment,
                      null, null,
                      null, null,
                      null, null,
                      oldTextValue, newTextValue);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createTextActivity(Issue issue, Attribute attribute,
                                                 ActivitySet activitySet, 
                                                 ActivityType type,
                                                 String description,
                                                 Attachment attachment,
                                                 String oldTextValue,
                                                 String newTextValue)
        throws TorqueException
    {
        return create(issue,attribute,activitySet,type,description,attachment,
                      null, null,
                      null, null,
                      null, null,
                      oldTextValue, newTextValue);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createReportIssueActivity(Issue issue, 
                                                     ActivitySet activitySet,
                                                     String message)
        throws TorqueException
    {
        return create(issue, AttributeManager.getInstance(ScarabConstants.INTEGER_0), 
                      activitySet, ActivityType.ISSUE_CREATED, null, null,
                      null, null, null, null, null, null, null, null);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity createDeleteIssueActivity(Issue issue, ActivitySet activitySet)
        throws TorqueException
    {
        return create(issue, AttributeManager.getInstance(ScarabConstants.INTEGER_0), 
                activitySet, ActivityType.ISSUE_DELETED, null, null,
                null, null, null, null, null, null, null, null);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity create(Issue issue, Attribute attribute, 
                       ActivitySet activitySet, ActivityType type, 
                       String description, Attachment attachment, 
                       Integer oldNumericValue, Integer newNumericValue,
                       Integer oldUserId, Integer newUserId,
                       Integer oldOptionId, Integer newOptionId,
                       String oldTextValue, String newTextValue)
         throws TorqueException
    {
        return create(issue,attribute,activitySet,type,description,attachment,null,
                      oldNumericValue, newNumericValue,
                      oldUserId, newUserId,
                      oldOptionId, newOptionId,
                      oldTextValue, newTextValue, null);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity create(Issue issue, Attribute attribute, 
                       ActivitySet activitySet, ActivityType type, 
                       String description, Attachment attachment, 
                       Integer oldNumericValue, Integer newNumericValue,
                       Integer oldUserId, Integer newUserId,
                       Integer oldOptionId, Integer newOptionId,
                       String oldTextValue, String newTextValue,
                       Connection dbCon)
         throws TorqueException
    {
        return create(issue,attribute,activitySet,type,description,attachment,null,
                      oldNumericValue, newNumericValue,
                      oldUserId, newUserId,
                      oldOptionId, newOptionId,
                      oldTextValue, newTextValue, dbCon);
    }
            
// in java/org/tigris/scarab/om/ActivityManager.java
public static Activity create(Issue issue, Attribute attribute,
                       ActivitySet activitySet, ActivityType type, 
                       String description, Attachment attachment, Depend depend,
                       Integer oldNumericValue, Integer newNumericValue,
                       Integer oldUserId, Integer newUserId,
                       Integer oldOptionId, Integer newOptionId,
                       String oldTextValue, String newTextValue, 
                       Connection dbCon)
         throws TorqueException
    {
        Activity activity = ActivityManager.getInstance();
        activity.setIssue(issue);
        if (attribute == null)
        {
            attribute = Attribute.getInstance(0);
        }
        activity.setAttribute(attribute);
        activity.setActivitySet(activitySet);
        activity.setOldNumericValue(oldNumericValue);
        activity.setNewNumericValue(newNumericValue);
        activity.setOldUserId(oldUserId);
        activity.setNewUserId(newUserId);
        activity.setOldOptionId(oldOptionId);
        activity.setNewOptionId(newOptionId);
        activity.setOldValue(oldTextValue);
        activity.setNewValue(newTextValue);
        activity.setDepend(depend);
        activity.setDescription(description);
        activity.setActivityType(type!=null?type.getCode():null);
        if (attachment != null)
        {
            activity.setAttachment(attachment);
        }
        if (dbCon == null) 
        {
            try
            {
                activity.save();
            }
            catch (Exception e)
            {
                if (e instanceof TorqueException) 
                {
                    throw (TorqueException)e; //EXCEPTION
                }
                else 
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        else 
        {
            activity.save(dbCon);
        }
        // Make sure new activity is added to activity cache
        try
        {
            issue.addActivity(activity);
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        return activity;
    }
            
// in java/org/tigris/scarab/om/PendingGroupUserRole.java
public void delete()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(PendingGroupUserRolePeer.GROUP_ID, getGroupId());
        crit.add(PendingGroupUserRolePeer.USER_ID, getUserId());
        crit.add(PendingGroupUserRolePeer.ROLE_NAME, getRoleName());
        PendingGroupUserRolePeer.doDelete(crit);
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(String key)
        throws TorqueException
    {
        return getInstance(new NumberKey(key));
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(Integer key)
        throws TorqueException
    {
        return getInstance(new NumberKey(key));
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final ActivitySetType tt, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return getInstance(tt.getTypeId(), user, null);
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final ActivitySetType tt, 
            final ScarabUser user, 
            final Attachment attachment)
        throws TorqueException, ScarabException
    {
        return getInstance(tt.getTypeId(), user, attachment);
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
            final ScarabUser user)
        throws TorqueException,ScarabException
    {
        return getInstance(typeId, user, null);
    }
            
// in java/org/tigris/scarab/om/ActivitySetManager.java
public static ActivitySet getInstance(final Integer typeId, 
                                          final ScarabUser user, 
                                          final Attachment attachment)
        throws TorqueException,ScarabException
    {
        if (attachment != null && attachment.getAttachmentId() == null) 
        {
            throw new ScarabException(L10NKeySet.ExceptionNeedToSaveAttachement);
        }
        final ActivitySet activitySet = new ActivitySet();
        activitySet.setTypeId(typeId);
        activitySet.setCreatedBy(user.getUserId());
        activitySet.setCreatedDate(new Date());
        if (attachment != null && 
            attachment.getData() != null &&
            attachment.getData().length() > 0)
        {
            activitySet.setAttachment(attachment);
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Activity.java
public AttributeOption getOldAttributeOption() throws TorqueException
    {
        if (oldAttributeOption==null && (getOldValue() != null))
        {
            oldAttributeOption = AttributeOptionManager
                .getInstance(new Integer(getOldValue()));
        }
        return oldAttributeOption;
    }
            
// in java/org/tigris/scarab/om/Activity.java
public AttributeOption getNewAttributeOption() throws TorqueException
    {
        if (newAttributeOption==null && (getNewValue() != null))
        {
            newAttributeOption = AttributeOptionManager
                .getInstance(new Integer(getNewValue()));
        }
        return newAttributeOption;
    }
            
// in java/org/tigris/scarab/om/Activity.java
public void save(Connection dbCon)
        throws TorqueException
    {
        if (isNew()) 
        {
            Criteria crit = new Criteria();
            // If there are previous activities on this attribute and value
            // Set End Date
            if (this.getOldValue() != null)
            {
                crit.add(ActivityPeer.ISSUE_ID, getIssueId());
                crit.add(ActivityPeer.ATTRIBUTE_ID, getAttributeId());
                crit.add(ActivityPeer.END_DATE, null);
                crit.add(ActivityPeer.NEW_VALUE, this.getOldValue());
                List<Activity> result = ActivityPeer.doSelect(crit);
                int resultSize = result.size();
                if (resultSize > 0)
                {
                    for (int i=0; i<resultSize;i++)
                    {
                        Activity a = (Activity)result.get(i);
                        a.setEndDate(getActivitySet().getCreatedDate());
                        a.save(dbCon);
                    }
                }
            }
        }
        // If they have just deleted a user assignment, set end date
        if (getAttribute().isUserAttribute() && this.getNewUserId() == null && this.getOldUserId() != null)
        {
            this.setEndDate(getActivitySet().getCreatedDate());
        }
        
        super.save(dbCon);
    }
            
// in java/org/tigris/scarab/om/Activity.java
public Activity copy(Issue issue, ActivitySet activitySet)
        throws TorqueException
    {
        Activity newA = new Activity();
        newA.setIssueId(issue.getIssueId());
        newA.setDescription(getDescription());
        newA.setAttributeId(getAttributeId());
        newA.setTransactionId(activitySet.getActivitySetId());
        newA.setOldNumericValue(getOldNumericValue());
        newA.setNewNumericValue(getNewNumericValue());
        newA.setOldUserId(getOldUserId());
        newA.setNewUserId(getNewUserId());
        newA.setOldValue(getOldValue());
        newA.setNewValue(getNewValue());
        newA.setDependId(getDependId());
        newA.setEndDate(getEndDate());
        newA.setAttachmentId(getAttachmentId());
        newA.setActivityType(getActivityType());
        newA.save();
        return newA;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void save(Connection con) throws TorqueException
    {
        if (isModified())
        {
            if (isNew())
            {
                super.save(con);
            }
            else
            { 
                RIssueTypeAttribute ria = null;
                try
                {
                    ria = getIssueType().getRIssueTypeAttribute(getAttribute());
                    if ((ria != null && ria.getLocked()))
                    {
                    throw new TorqueException(getAttribute().getName() + " is locked"); //EXCEPTION
                    }
                    else
                    {
                        super.save(con);
                    }
                }
                catch (Exception e)
                {
                    throw new TorqueException("An error has occurred.", e); //EXCEPTION
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void delete()
         throws TorqueException, ScarabException
    {                
         delete(false);
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
protected void delete(final boolean overrideLock)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

        final IssueType issueType = IssueTypeManager
           .getInstance(getIssueTypeId(), false);
        if (issueType.getLocked() && !overrideLock)
        { 
            throw new ScarabException(L10NKeySet.CannotDeleteAttributeFromLockedIssueType);
        }            
        else
        {
            final Criteria c = new Criteria()
                .add(RModuleAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleAttributePeer.doDelete(c);
            final Attribute attr = getAttribute();
            String attributeType = null;
            attributeType = (attr.isUserAttribute() ? Module.USER : Module.NON_USER);
            module.getRModuleAttributes(getIssueType(), false, attributeType)
                                        .remove(this);
            WorkflowFactory.getInstance().deleteWorkflowsForAttribute(
                                          attr, module, getIssueType());

            // delete module-user-attribute mappings
            final Criteria crit = new Criteria()
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attr.getAttributeId())
                .add(RModuleUserAttributePeer.MODULE_ID, 
                     getModuleId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                     getIssueTypeId());
            RModuleUserAttributePeer.doDelete(crit);

            // delete module-option mappings
            if (attr.isOptionAttribute())
            {
                final List optionList = module.getRModuleOptions(attr, 
                                  IssueTypePeer.retrieveByPK(getIssueTypeId()), 
                                  false);
                if (optionList != null && !optionList.isEmpty())
                {
                    final List optionIdList =
                        new ArrayList(optionList.size());
                    for (int i = 0; i < optionList.size(); i++)
                    { 
                        optionIdList.add(((RModuleOption)
                                          optionList.get(i))
                                         .getOptionId());
                    }
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID, getModuleId())
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,
                             getIssueTypeId())
                        .addIn(RModuleOptionPeer.OPTION_ID, optionIdList);
                    RModuleOptionPeer.doDelete(c2);
                }
            }
        }

        RModuleAttributeManager.removeInstanceFromCache(this);
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
private static List getRMAs(Integer moduleId, Integer issueTypeId)
    throws TorqueException
{
    List result = null;
    Object obj = ScarabCache.get(R_MODULE_ATTTRIBUTE, GET_RMAS, 
                                 moduleId, issueTypeId); 
    if (obj == null) 
    {        
        Criteria crit = new Criteria()
            .add(RModuleAttributePeer.MODULE_ID, moduleId)
            .add(RModuleAttributePeer.ISSUE_TYPE_ID, issueTypeId);
        crit.addAscendingOrderByColumn(
            RModuleAttributePeer.PREFERRED_ORDER);
        result = RModuleAttributePeer.doSelect(crit);
        ScarabCache.put(result, R_MODULE_ATTTRIBUTE, GET_RMAS, 
                        moduleId, issueTypeId);
    }
    else 
    {
        result = (List)obj;
    }
    return result;
}
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
private static List<RModuleAttribute> getRMAs(Integer moduleId)
    throws TorqueException
{
    List<RModuleAttribute> result = null;
    Object obj = ScarabCache.get(R_MODULE_ATTTRIBUTE, GET_RMAS, moduleId); 
    if (obj == null) 
    {        
        Criteria crit = new Criteria()
            .add(RModuleAttributePeer.MODULE_ID, moduleId);
        crit.addAscendingOrderByColumn(
            RModuleAttributePeer.PREFERRED_ORDER);
        result = (List<RModuleAttribute>)RModuleAttributePeer.doSelect(crit);
        ScarabCache.put(result, R_MODULE_ATTTRIBUTE, GET_RMAS, 
                        moduleId);
    }
    else 
    {
        result = (List<RModuleAttribute>)obj;
    }
    return result;
}
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public static List<Integer> getRMAIds(Integer moduleId)
    throws TorqueException
    {
        List<RModuleAttribute> rmas = getRMAs(moduleId);
        Iterator<RModuleAttribute> iter = rmas.iterator();
        List<Integer> result = new ArrayList();
        while(iter.hasNext())
        {
            RModuleAttribute rma = iter.next();
            result.add(rma.getAttributeId());
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public boolean getIsDefaultText()
        throws TorqueException
    {
        boolean isDefault = getDefaultTextFlag();
        if (!isDefault && getAttribute().isTextAttribute()) 
        {
            // get related RMAs
            List rmas = getRMAs(getModuleId(), getIssueTypeId());
            
            // check if another is chosen
            boolean anotherIsDefault = false;
            for (int i=0; i<rmas.size(); i++) 
            {
                RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
                if (rma.getDefaultTextFlag()) 
                {
                    anotherIsDefault = true;
                    break;
                }
            }
            
            if (!anotherIsDefault) 
            {
                // locate the default text attribute
                for (int i=0; i<rmas.size(); i++) 
                {
                    RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
                    if (rma.getAttribute().isTextAttribute()) 
                    {
                        if (rma.getAttributeId().equals(getAttributeId())) 
                        {
                            isDefault = true;
                        }
                        else 
                        {
                            anotherIsDefault = true;
                        }
                        
                        break;
                    }
                }
            }            
        }
        return isDefault;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setIsDefaultText(boolean b)
        throws TorqueException
    {
        if (b && !getDefaultTextFlag()) 
        {
            // get related RMAs
            List rmas = getRMAs(getModuleId(), getIssueTypeId());
            
            // make sure no other rma is selected
            for (int i=0; i<rmas.size(); i++) 
            {
                RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
                if (rma.getDefaultTextFlag()) 
                {
                    rma.setDefaultTextFlag(false);
                    rma.save();
                    break;
                }
            }
        }
        setDefaultTextFlag(b);
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public List<Condition> getConditions() throws TorqueException
    {
        if (collConditions == null)
        {
            Criteria crit = new Criteria();
            crit.add(ConditionPeer.ATTRIBUTE_ID, this.getAttributeId());
            crit.add(ConditionPeer.MODULE_ID, this.getModuleId());
            crit.add(ConditionPeer.ISSUE_TYPE_ID, this.getIssueTypeId());
            crit.add(ConditionPeer.TRANSITION_ID, null);
            collConditions = getConditions(crit);
        }
        return collConditions;
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setConditionsArray(Integer aOptionId[], Integer operator) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.ATTRIBUTE_ID, this.getAttributeId());
        crit.add(ConditionPeer.MODULE_ID, this.getModuleId());
        crit.add(ConditionPeer.ISSUE_TYPE_ID, this.getIssueTypeId());
        crit.add(ConditionPeer.TRANSITION_ID, null);
        ConditionPeer.doDelete(crit);
        this.getConditions().clear();
        ConditionManager.clear();
        if (aOptionId != null)
        {
	        for (int i=0; i<aOptionId.length; i++)
	        {
	            if (aOptionId[i].intValue() != 0)
	            {
		            Condition cond = new Condition();
		            cond.setAttribute(this.getAttribute());
		            cond.setOptionId(aOptionId[i]);
		            cond.setTransitionId(null);
		            cond.setIssueTypeId(this.getIssueTypeId());
		            cond.setModuleId(this.getModuleId());
		            cond.setOperator(operator);
		            this.addCondition(cond);
		            cond.save();
	            }
	        }
        }
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public boolean isRequiredIf(Integer optionID) throws TorqueException
    {
        Condition condition = new Condition();
        condition.setAttribute(this.getAttribute());
        condition.setModuleId(this.getModuleId());
        condition.setIssueTypeId(this.getIssueTypeId());
        condition.setTransitionId(new Integer(0));
        condition.setOptionId(optionID);
        return this.getConditions().contains(condition);
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public RModuleAttribute getRModuleAttribute(IssueType issueType)
        throws TorqueException
    {
        Module module = ModuleManager.getInstance(getModuleId());
        Attribute attribute = getAttributeOption().getAttribute();
        return module.getRModuleAttribute(attribute, issueType);
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public List getDescendants(IssueType issueType)
        throws TorqueException
    {
        List descendants = new ArrayList();
        List attrDescendants = getAttributeOption().getDescendants();
        for (int i =0;i < attrDescendants.size(); i++)
        { 
            RModuleOption rmo = null;
            AttributeOption option = (AttributeOption)attrDescendants.get(i);
            rmo = getModule().getRModuleOption(option, issueType);
            if (rmo != null && rmo.getOptionId().equals(option.getOptionId()))
            {
                descendants.add(rmo);
            }
        }
        return descendants;
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public List<RModuleOption> getChildren(IssueType issueType) throws TorqueException {
    	List<RModuleOption> children = new ArrayList<RModuleOption>();
    	
        @SuppressWarnings("unchecked")
    	List<AttributeOption> l = (List<AttributeOption>) this.getAttributeOption().getChildren();
    	
    	for (AttributeOption attrOption : l) {
    		RModuleOption rmo = getModule().getRModuleOption(attrOption, issueType);
            if (rmo != null && rmo.getOptionId().equals(attrOption.getOptionId())) {
            	children.add(rmo);
            }
    	}
    	
    	return children;    	
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public void delete()
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();

            final IssueType issueType = IssueTypeManager
               .getInstance(getIssueTypeId(), false);
            if (issueType.getLocked())
            { 
                throw new ScarabException(L10NKeySet.ExceptionDeleteOptionFromLockedIssueType);
            }            
            else
            {
                Integer moduleId    = getModuleId();
                Integer issueTypeId = getIssueTypeId();
                Integer optionId    = getOptionId();
                int orderNumber     = getOrder();

                // delete the option
                final Criteria c = new Criteria()
                    .add(RModuleOptionPeer.MODULE_ID, moduleId)
                    .add(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId)
                    .add(RModuleOptionPeer.OPTION_ID, optionId);
                RModuleOptionPeer.doDelete(c);
                
                // delete associated workflow
                WorkflowFactory.getInstance().deleteWorkflowsForOption(getAttributeOption(), 
                                             module, issueType);

                // ======================================================
                // Correct the ordering of the remaining options
                // ======================================================

                // first retrieve the list of still available option ids
                final List optIds = new ArrayList();
                final List rmos = module.getRModuleOptions(getAttributeOption().getAttribute(), issueType, false);
                for (int i=0; i<rmos.size();i++)
                {
                    final RModuleOption rmo = (RModuleOption)rmos.get(i);
                    optIds.add(rmo.getOptionId());
                }
               
                // Need to perform the correction only if the deleted option had follow up options
                if(optIds.size() > 0)
                {
                    // update the list
                    final Criteria c2 = new Criteria()
                        .add(RModuleOptionPeer.MODULE_ID,       moduleId)
                        .add(RModuleOptionPeer.ISSUE_TYPE_ID,   issueTypeId)
                        .addIn(RModuleOptionPeer.OPTION_ID,     optIds)
                        .add(RModuleOptionPeer.PREFERRED_ORDER, orderNumber, Criteria.GREATER_THAN);
                    final List adjustRmos = RModuleOptionPeer.doSelect(c2);
                    for (int j=0; j<adjustRmos.size();j++)
                    {
                        final RModuleOption rmo = (RModuleOption)adjustRmos.get(j);
                        //rmos.remove(rmo);
                        rmo.setOrder(rmo.getOrder() -1);
                        rmo.save();
                        //rmos.add(rmo);
                    }
                }
            }
            // notify module cache of this change
            ((ModuleManager)Torque.getManager(ModuleManager.MANAGED_CLASS))
                .refreshedObject(this);
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public void save(Connection con) throws TorqueException
    {
        if (isModified())
        {
            if (isNew())
            {
                super.save(con);
            }
            else
            {
                Attribute attr = getAttributeOption().getAttribute();
                RIssueTypeAttribute ria = null;
                try
                {
                    ria = getIssueType().getRIssueTypeAttribute(attr);
                    if (ria != null && ria.getLocked())
                    {
                        throw new TorqueException(attr.getName() + "is locked"); //EXCEPTION
                    }
                    else
                    {
                        super.save(con);
                    }
                }
                catch (Exception e)
                {
                    throw new TorqueException("An error has occurred."); //EXCEPTION
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public static List<Integer> getRMOIds(Integer moduleId) throws TorqueException 
    {
        List<RModuleOption> rmos = getRMOs(moduleId);
        Iterator<RModuleOption> iter = rmos.iterator();
        List<Integer> result = new ArrayList();
        while(iter.hasNext())
        {
            RModuleOption rmo = iter.next();
            result.add(rmo.getOptionId());
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public static List<RModuleOption> getRMOs(Integer moduleId)
    throws TorqueException
    {
        List<RModuleOption> result = null;
        Object obj = ScarabCache.get(R_MODULE_OPTION, GET_RMOS, moduleId); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(RModuleOptionPeer.MODULE_ID, moduleId);
            crit.addAscendingOrderByColumn(
                RModuleOptionPeer.PREFERRED_ORDER);
            result = (List<RModuleOption>)RModuleOptionPeer.doSelect(crit);
            ScarabCache.put(result, R_MODULE_OPTION, GET_RMOS, 
                            moduleId);
        }
        else 
        {
            result = (List<RModuleOption>)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public static List<RModuleOption> getRMOs(Integer moduleId, Integer issueTypeId) throws TorqueException
    {
        List<RModuleOption> result = null;
        Object obj = ScarabCache.get(R_MODULE_OPTION, GET_RMOS_FOR_ISSUETYPE , moduleId, issueTypeId); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
            .add(RModuleOptionPeer.MODULE_ID, moduleId)
            .and(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId);
            crit.addAscendingOrderByColumn(
                RModuleOptionPeer.PREFERRED_ORDER);
            result = (List<RModuleOption>)RModuleOptionPeer.doSelect(crit);
            ScarabCache.put(result, R_MODULE_OPTION, GET_RMOS_FOR_ISSUETYPE , moduleId, issueTypeId);
        }
        else 
        {
            result = (List<RModuleOption>)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public static List<RModuleOption> getRMOs(Integer moduleId, Integer issueTypeId, String displayValue) throws TorqueException
    {
        List<RModuleOption> result = null;
        Object obj = ScarabCache.get(R_MODULE_OPTION, GET_RMOS_FOR_ISSUETYPE_AND_VALUE , moduleId, issueTypeId, displayValue); 
        if (obj == null) 
        {
            Criteria crit = new Criteria()
            .add(RModuleOptionPeer.MODULE_ID, moduleId)
            .and(RModuleOptionPeer.ISSUE_TYPE_ID, issueTypeId)
            .and(RModuleOptionPeer.DISPLAY_VALUE, displayValue);
            crit.addAscendingOrderByColumn(
                RModuleOptionPeer.PREFERRED_ORDER);
            result = (List<RModuleOption>)RModuleOptionPeer.doSelect(crit);
            ScarabCache.put(result, R_MODULE_OPTION, GET_RMOS_FOR_ISSUETYPE_AND_VALUE , moduleId, issueTypeId, displayValue);
        }
        else 
        {
            result = (List<RModuleOption>)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public static RModuleOption getFirstRMO(Integer moduleId, Integer issueTypeId, String displayValue) throws TorqueException
    {
        RModuleOption result = null;
        List<RModuleOption> rmos = getRMOs(moduleId, issueTypeId, displayValue);
        if (rmos != null && rmos.size() > 0)
        {
            result = rmos.get(0);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributeClassManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(AttributeClassPeer.ATTRIBUTE_CLASS_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/AttachmentPeer.java
public static Attachment retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        Attachment result = null;
        Object obj = ScarabCache.get(ATTACHMENT_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseAttachmentPeer.retrieveByPK(pk);
            ScarabCache.put(result, ATTACHMENT_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (Attachment)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/ActivityPeer.java
public static String getNewIssueUniqueId(Issue issue)
        throws TorqueException
    {
        String id = issue.getUniqueId();
        Criteria crit = new Criteria();
        crit.add(ActivityPeer.OLD_VALUE, id);
        crit.add(ActivityPeer.ACTIVITY_TYPE, ActivityType.ISSUE_MOVED.getCode());
        crit.addDescendingOrderByColumn(ActivityPeer.ACTIVITY_ID);
        List list = doSelect(crit);
        if (list != null && list.size() > 0)
            id = ((Activity)list.get(0)).getNewValue();
        return id;
    }
            
// in java/org/tigris/scarab/om/QueryManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        //List listeners = (List)listenersMap
        //    .get(AttributeTypePeer.ATTRIBUTE_TYPE_ID);
        //notifyListeners(listeners, oldOm, om);
        getMethodResult().removeAll(QueryPeer.QUERY_PEER, 
                                    QueryPeer.GET_QUERIES);
        getMethodResult().removeAll(QueryPeer.QUERY_PEER, 
                                    QueryPeer.GET_USER_QUERIES);
        getMethodResult().removeAll(QueryPeer.QUERY_PEER, 
                                    QueryPeer.GET_MODULE_QUERIES);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getInstance()
        throws TorqueException
    {
        return new ScarabUserImpl();
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getInstance(final String username)
        throws TorqueException
    {
        ScarabUser user = (ScarabUser) getMethodResult().get(SCARAB_USER_MANAGER, GET_INSTANCE, username );
        if (user == null)
        {
             user = getManager().getInstanceImpl(username);
             if(user!=null)
                 getMethodResult().put(user, SCARAB_USER_MANAGER, GET_INSTANCE, username);
        }
        return user;
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getInstanceByEmail(final String email) 
        throws TorqueException,ScarabException
    {
        return getManager().getInstanceByEmailImpl(email);
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static List getUsers(final String[] usernames) 
        throws TorqueException
    {
        return getManager().getUsersImpl(usernames);
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected ScarabUser getInstanceImpl(final String username) 
        throws TorqueException
    {
        ScarabUser user = null;
        if (username != null) 
        {
            final Criteria crit = new Criteria();
            crit.add(ScarabUserImplPeer.USERNAME, username);
            crit.setSingleRecord(true);
            final List users = ScarabUserImplPeer.doSelect(crit);
            if (users.size() == 1) 
            {
                user = (ScarabUser)users.get(0);
            }
        }
        return user;
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected ScarabUser getInstanceByEmailImpl(final String email) 
        throws TorqueException,ScarabException
    {
        ScarabUser user = null;
        if (email != null) 
        {
            final Criteria crit = new Criteria();
            crit.add(ScarabUserImplPeer.EMAIL, email);
            final List users = ScarabUserImplPeer.doSelect(crit);
            if (users.size() == 1) 
            {
                user = (ScarabUser)users.get(0);
            }
            else if (users.size() > 1) 
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateUsername); 
            }
        }
        return user;
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
protected List getUsersImpl(final String[] usernames) 
        throws TorqueException
    {
        List users = null;
        if (usernames != null && usernames.length > 0) 
        {
            final Criteria crit = new Criteria();
            crit.addIn(ScarabUserImplPeer.USERNAME, usernames);
            users = ScarabUserImplPeer.doSelect(crit);            
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static ScarabUser getAnonymousUser()
	    throws TorqueException
	{
		ScarabUser user = null;
	    if(anonymousAccessAllowed())
	    {
	        String username = getAnonymousUserName();
	        user = getInstance(username);
	    }
	    if (user == null)
	    {
	        try
	        {
	    	    user = (ScarabUser) TurbineSecurity.getAnonymousUser();
	        }
	        catch (Exception e)
	        {
	        	throw new RuntimeException(e);
	        }
	    }
	    return user;
	}
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static String getAnonymousUserName()
	    throws TorqueException
	{
	    String username = GlobalParameterManager.getString("scarab.anonymous.username");
	    return username;
	}
            
// in java/org/tigris/scarab/om/ScarabUserManager.java
public static boolean anonymousAccessAllowed()
		throws TorqueException
	{
	    boolean allowed = GlobalParameterManager.getBoolean("scarab.anonymous.enable");
	    return allowed;
	}
            
// in java/org/tigris/scarab/om/RModuleAttributePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/RModuleAttributePeer.java
public static RModuleAttribute retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        RModuleAttribute result = null;
        Object obj = ScarabCache.get(RMODULEATTRIBUTE_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseRModuleAttributePeer.retrieveByPK(pk);
            ScarabCache.put(result, RMODULEATTRIBUTE_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (RModuleAttribute)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/RModuleAttributePeer.java
public static void doDelete(RModuleAttribute rma) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.MODULE_ID, rma.getModuleId());
        crit.add(ConditionPeer.ISSUE_TYPE_ID, rma.getIssueTypeId());
        crit.add(ConditionPeer.ATTRIBUTE_ID, rma.getAttributeId());
        ConditionPeer.doDelete(crit);
        BaseTransitionPeer.doDelete(crit);
    }
            
// in java/org/tigris/scarab/om/AttributeOptionPeer.java
public static List getSortedAttributeOptions() throws TorqueException 
    {
      List attributeOptions = null;
      final Criteria crit = new Criteria();
      crit.addAscendingOrderByColumn(AttributeOptionPeer.ATTRIBUTE_ID);
      crit.addAscendingOrderByColumn(AttributeOptionPeer.OPTION_ID);
      attributeOptions = doSelect(crit);
      attributeOptions.remove(0);
      return attributeOptions;  
    }
            
// in java/org/tigris/scarab/om/AttributeOptionPeer.java
public static List<AttributeOption> getSortedAttributeOptions(Module module) throws TorqueException 
    {
        List<Integer> rmaIds = RModuleAttribute.getRMAIds(module.getModuleId());
        //List<Integer> rmoIds = RModuleOption.getRMOIds(module.getModuleId());
        List<AttributeOption> attributeOptions = null;
        final Criteria crit = new Criteria();
      
        //SELECT * FROM scarab_attribute_option s where attribute_id in (select distinct attribute_id from scarab_r_module_attribute where module_id=10001);
        crit.addIn(AttributeOptionPeer.ATTRIBUTE_ID,rmaIds);
        crit.add(AttributeOptionPeer.DELETED,0);
        crit.addAscendingOrderByColumn(AttributeOptionPeer.ATTRIBUTE_ID);
        crit.addAscendingOrderByColumn(AttributeOptionPeer.OPTION_ID);
        attributeOptions = (List<AttributeOption>)doSelect(crit);
        //attributeOptions.remove(0);
        return attributeOptions;  
    }
            
// in java/org/tigris/scarab/om/RQueryUser.java
public void delete(ScarabUser user) throws TorqueException
                                                             
    { 
        if (user.getUserId().equals(getUserId()))
        {
            Criteria c = new Criteria()
                .add(RQueryUserPeer.USER_ID, getUserId())
                .add(RQueryUserPeer.QUERY_ID, getQueryId());
            RQueryUserPeer.doDelete(c);
        }
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public AttributeOption getChildOption()
        throws TorqueException
    {
        return AttributeOptionManager.getInstance(getOptionId());
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public AttributeOption getParentOption()
        throws TorqueException
    {
        return AttributeOptionManager.getInstance(getParentId());
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public List getAncestors()
        throws TorqueException, Exception
    {
        ancestors = new ArrayList();
        AttributeOption parent = getParentOption();
        if (!ROOT_ID.equals(parent.getOptionId()))
        {
            addAncestors(parent);
        }
        return ancestors;
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
private void addAncestors(AttributeOption option)
        throws TorqueException, Exception
    {
        if (!ROOT_ID.equals(option.getParent().getOptionId()))
        {
            if (ancestors.contains(option.getParent()))
            {
                throw new TorqueException("Tried to add a recursive parent-child " +
                                    "attribute option relationship."); //EXCEPTION
            }
            else
            { 
                addAncestors(option.getParent());
            }
        }
        ancestors.add(option.getOptionId());
    }
            
// in java/org/tigris/scarab/om/ParentChildAttributeOption.java
public void save()
        throws TorqueException, ScarabException
    {
        AttributeOption ao = null;
        ROptionOption roo = null;

        final Attribute tmpAttr = AttributeManager.getInstance(getAttributeId());
        
        // if it is new, it won't already have an optionId
        if (getOptionId() == null)
        {
            // if it is new, check for duplicates.
            final AttributeOption duplicate = 
                AttributeOptionManager.getInstance(tmpAttr, getName().trim());
            final AttributeOption parent = 
                AttributeOptionManager.getInstance(getParentId());
            if (duplicate != null)
            {
                throw new ScarabException (new L10NKey("CannotCreateDuplicateOption")); //EXCEPTION
            }
            else if (parent.getDeleted())
            {
                throw new ScarabException (new L10NKey("CannotCreateChild")); //EXCEPTION
            }
        }

        // if getOptionId() is null, then it will just create a new instance
        final Integer optionId = getOptionId();
        if (optionId == null)
        {
            ao = AttributeOptionManager.getInstance();
        } 
        else
        {
            ao = AttributeOptionManager.getInstance(getOptionId());
        }

        
        ao.setName(getName());
        ao.setDeleted(getDeleted());
        ao.setAttribute(tmpAttr);
        ao.setStyle(getStyle());
        ao.save();

        // clean out the caches for the AO
        tmpAttr.doRemoveCaches();

        // now set our option id from the saved AO
        this.setOptionId(ao.getOptionId());

        // now create the ROO mapping
        try
        {
            // look for a cached ROptionOption
            roo = ROptionOption.getInstance(getParentId(), getOptionId());
        }
        catch (ScarabException se)
        {
            // could not find a cached instance create new one
            roo = ROptionOption.getInstance();
            roo.setOption1Id(getParentId());
            roo.setOption2Id(getOptionId());
        }
        roo.setPreferredOrder(getPreferredOrder());
        roo.setWeight(getWeight());
        roo.setRelationshipId(OptionRelationship.PARENT_CHILD);
        roo.save();
    }
            
// in java/org/tigris/scarab/om/AttributeGroupPeer.java
public static AttributeGroup retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        AttributeGroup result = null;
        Object obj = ScarabCache.get(ATTRIBUTEGROUP_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseAttributeGroupPeer.retrieveByPK(pk);
            ScarabCache.put(result, ATTRIBUTEGROUP_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (AttributeGroup)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributeOptionManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttributeOptionPeer.OPTION_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/AttributeOptionManager.java
public static AttributeOption getInstance(final Attribute attribute, 
            final String name)
        throws TorqueException
    {
        return getInstance(attribute, name, (Module) null, (IssueType) null);
    }
            
// in java/org/tigris/scarab/om/AttributeOptionManager.java
public static AttributeOption getInstance(final Attribute attribute, 
                                              final String name,
                                              final Module module,
                                              final IssueType issueType)
        throws TorqueException
    {
        AttributeOption ao = null;
        Criteria crit;
        // FIXME: Optimize this implementation!  It is grossly
        // inefficient, which is problematic given how often it may be
        // used.
        if (module != null && issueType != null)
        {
            // Look for a module-scoped alias.
            crit = new Criteria(4);
            crit.add(AttributeOptionPeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId());
            crit.addJoin(AttributeOptionPeer.OPTION_ID, 
                         RModuleOptionPeer.OPTION_ID); 
            crit.add(RModuleOptionPeer.MODULE_ID, module.getModuleId());
            crit.add(RModuleOptionPeer.ISSUE_TYPE_ID,
                     issueType.getIssueTypeId());
            crit.add(RModuleOptionPeer.DISPLAY_VALUE, name);
            final List rmos = RModuleOptionPeer.doSelect(crit);
            if (rmos.size() == 1)
            {
                final RModuleOption rmo = (RModuleOption) rmos.get(0);
                ao = rmo.getAttributeOption();
            }
        }

        if (ao == null)
        {
            // TODO It seems that we might not necessarily get the global option.
            // Do we want to add a criteria to limit to getting the global option?
            // This would be either "= 0" or "is null".
             
            crit = new Criteria(2);
            crit.add(AttributeOptionPeer.OPTION_NAME, name);
            crit.add(AttributeOptionPeer.ATTRIBUTE_ID,
                     attribute.getAttributeId());
            crit.setIgnoreCase(true);
            final List options = AttributeOptionPeer.doSelect(crit);
            if (options.size() == 1)
            {
                ao =  (AttributeOption) options.get(0);
            }
        }
        return ao;
    }
            
// in java/org/tigris/scarab/om/IssueTypeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(IssueTypePeer.ISSUE_TYPE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/ROptionOption.java
public static void doRemove(ROptionOption roo)
        throws TorqueException
    {
        // using Criteria because there is a bug in Torque
        // where doDelete(roo) doesn't work because it has
        // multple primary keys
        Criteria crit = new Criteria();
        crit.add (ROptionOptionPeer.OPTION1_ID, roo.getOption1Id());
        crit.add (ROptionOptionPeer.OPTION2_ID, roo.getOption2Id());

        ROptionOptionPeer.doDelete(crit);
    }
            
// in java/org/tigris/scarab/om/ROptionOption.java
public static void doRemove(Integer parent, Integer child)
        throws TorqueException
    {
        ROptionOption roo = getInstance();
        roo.setOption1Id(parent);
        roo.setOption2Id(child);
        ROptionOption.doRemove(roo);
    }
            
// in java/org/tigris/scarab/om/ROptionOption.java
public AttributeOption getOption1Option()
        throws TorqueException
    {
        return AttributeOptionManager.getInstance(getOption1Id());
    }
            
// in java/org/tigris/scarab/om/ROptionOption.java
public AttributeOption getOption2Option()
        throws TorqueException
    {
        return AttributeOptionManager.getInstance(getOption2Id());
    }
            
// in java/org/tigris/scarab/om/FrequencyPeer.java
public static List getFrequencies() throws TorqueException
    {
        return doSelect(new Criteria());
    }
            
// in java/org/tigris/scarab/om/UserPreference.java
public void save() throws TorqueException
    {
        if (!this.getScarabUser().isUserAnonymous())
        {
            super.save();
        }
    }
            
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
public void delete(final ScarabUser user) throws TorqueException, TurbineSecurityException 
    { 
        boolean hasPermission = true;
        if (getModule() != null)
        {
            hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,getModule());
        }
        else //getModule() is null for X Project queries, so get the modules from the MIT List
        {
            final List moduleList = user.getCurrentMITList().getModules();
            for (Iterator iter = moduleList.iterator(); iter.hasNext(); )
            {
                hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,(Module)iter.next());
                if (!hasPermission)
                {
                    break;
                }
            }
        }
        if (hasPermission)
        {
            final Criteria c = new Criteria()
                .add(RModuleUserAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleUserAttributePeer.LIST_ID, getListId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleUserAttributePeer.doDelete(c);
        }
        else
        {
            throw new TurbineSecurityException(ScarabConstants.NO_PERMISSION_MESSAGE); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/om/AttributeValueManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttributeValuePeer.ISSUE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/ActivitySetType.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException, ScarabException
    {
        return ActivitySetTypeManager.getInstance(activitySetTypeName);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImplPeer.java
public static int getUsersCount(final Criteria critCount) 
        throws TorqueException, DataSetException
    {
        final List resultCount = ScarabUserImplPeer.doSelectVillageRecords(critCount);
        final Record record = (Record) resultCount.get(0);                
        return record.getValue(1).asInt();        
    }
            
// in java/org/tigris/scarab/om/IssuePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/IssuePeer.java
public static int countDistinct(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT_DISTINCT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/IssuePeer.java
public static Issue retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        Issue result = null;
        Object obj = ScarabCache.get(ISSUE_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseIssuePeer.retrieveByPK(pk);
            ScarabCache.put(result, ISSUE_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (Issue)obj;
        }
        
        result = BaseIssuePeer.retrieveByPK(pk);
        return result;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public String getPort() 
        throws TorqueException
    {
        if (port == null)
        {
            port = GlobalParameterManager
                    .getString(ScarabConstants.HTTP_PORT);
        }
        return port;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public String getScheme() 
        throws TorqueException
    {
        if (scheme == null)
        {
            scheme = GlobalParameterManager
                    .getString(ScarabConstants.HTTP_SCHEME);
        }
        return scheme;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public String getScriptName() 
        throws TorqueException
    {
        if (scriptName == null)
        {
            scriptName = GlobalParameterManager
                    .getString(ScarabConstants.HTTP_SCRIPT_NAME);
        }
        return scriptName;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public ScarabPaginatedList getUsers(final String name, 
                                        final String username, 
                                        final MITList mitList, 
                                        final int pageNum, 
                                        final int resultsPerPage,
                                        final String sortColumn, 
                                        final String sortPolarity,
                                        final boolean includeCommitters)
        throws TorqueException, DataSetException
    {
    	return getUsers(name, username, mitList, pageNum, resultsPerPage, sortColumn, sortPolarity, includeCommitters, false);
    	
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public ScarabPaginatedList getUsers(final String name, 
                                        final String username, 
                                        final MITList mitList, 
                                        final int pageNum, 
                                        final int resultsPerPage,
                                        final String sortColumn, 
                                        final String sortPolarity,
                                        final boolean includeCommitters,
                                        final boolean confirmedOnly)
        throws TorqueException, DataSetException
    {
        final int polarity = sortPolarity.equals("asc") ? 1 : -1; 
        List result = null;
        ScarabPaginatedList paginated = null; 

        final Comparator c = new Comparator() 
        {
            public int compare(Object o1, Object o2) 
            {
                int i = 0;
                if ("username".equals(sortColumn))
                {
                    i =  polarity * ((ScarabUser)o1).getUserName()
                              .compareTo(((ScarabUser)o2).getUserName());
                }
                else
                {
                    i =  polarity * ((ScarabUser)o1).getName()
                             .compareTo(((ScarabUser)o2).getName());
                }
                return i;
             }
        };

            final Criteria crit = new Criteria();//
            final Criteria critCount = new Criteria();
            critCount.addSelectColumn("COUNT(DISTINCT " + TurbineUserPeer.USERNAME + ")");
            if (mitList != null)
            {
                final List modules = mitList.getModules();
                for (Iterator it = modules.iterator(); it.hasNext(); )
                {
                    final Module mod = (Module)it.next();
                    final List perms = mitList.getUserAttributePermissions();
                    if (includeCommitters && !perms.contains(org.tigris.scarab.services.security.ScarabSecurity.ISSUE__ENTER))
                    {
                        perms.add(org.tigris.scarab.services.security.ScarabSecurity.ISSUE__ENTER);
                    }

                    crit.addIn(TurbinePermissionPeer.PERMISSION_NAME, perms);
                    crit.setDistinct();
                    critCount.addIn(TurbinePermissionPeer.PERMISSION_NAME, perms);
                }
                crit.addIn(TurbineUserGroupRolePeer.GROUP_ID, mitList.getModuleIds());
                critCount.addIn(TurbineUserGroupRolePeer.GROUP_ID, mitList.getModuleIds());
            }
            crit.addJoin(TurbineUserPeer.USER_ID, TurbineUserGroupRolePeer.USER_ID);
            crit.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePermissionPeer.ROLE_ID);
            crit.addJoin(TurbineRolePermissionPeer.PERMISSION_ID, TurbinePermissionPeer.PERMISSION_ID);
            critCount.addJoin(TurbineUserPeer.USER_ID, TurbineUserGroupRolePeer.USER_ID);
            critCount.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePermissionPeer.ROLE_ID);
            critCount.addJoin(TurbineRolePermissionPeer.PERMISSION_ID, TurbinePermissionPeer.PERMISSION_ID);            

			//user by name
            if (name != null)
            {
                int nameSeparator = name.indexOf(" ");
                if (nameSeparator != -1) 
                {
                    final String firstName = name.substring(0, nameSeparator);
                    final String lastName = name.substring(nameSeparator+1, name.length());
                    crit.add(ScarabUserImplPeer.FIRST_NAME, 
                             addWildcards(firstName), Criteria.LIKE);
                    crit.add(ScarabUserImplPeer.LAST_NAME, 
                             addWildcards(lastName), Criteria.LIKE);
                    critCount.add(ScarabUserImplPeer.FIRST_NAME, 
                            addWildcards(firstName), Criteria.LIKE);
                    critCount.add(ScarabUserImplPeer.LAST_NAME, 
                            addWildcards(lastName), Criteria.LIKE);
                    
                }
                else 
                {
                    String[] tableAndColumn = StringUtils.split(ScarabUserImplPeer.FIRST_NAME, ".");
                    final Criteria.Criterion fn = crit.getNewCriterion(tableAndColumn[0],
                                                                 tableAndColumn[1], 
                                                                 addWildcards(name), 
                                                                 Criteria.LIKE);
                    tableAndColumn = StringUtils.split(ScarabUserImplPeer.LAST_NAME, ".");
                    final Criteria.Criterion ln = crit.getNewCriterion(tableAndColumn[0],
                                                                 tableAndColumn[1], 
                                                                 addWildcards(name), 
                                                                 Criteria.LIKE);
                    fn.or(ln);
                    crit.add(fn);
                    critCount.add(fn);
                }
            }

            if (username != null)
            {
                crit.add(ScarabUserImplPeer.LOGIN_NAME, 
                         addWildcards(username), Criteria.LIKE);
                critCount.add(ScarabUserImplPeer.LOGIN_NAME, 
                        addWildcards(username), Criteria.LIKE);
            }
            
            String col = ScarabUserImplPeer.FIRST_NAME;
            if (sortColumn.equals("username"))
                col = ScarabUserImplPeer.USERNAME;
            if (sortPolarity.equals("asc"))
            {
                crit.addAscendingOrderByColumn(col);
            }
            else
            {
                crit.addDescendingOrderByColumn(col);
            }
            
            //confirmed users only
            if(confirmedOnly){
            	crit.add(ScarabUserImplPeer.CONFIRM_VALUE, (Object)"CONFIRMED", Criteria.EQUAL);
            }

			//finish query
            final int totalResultSize = ScarabUserImplPeer.getUsersCount(critCount);
            
            crit.setOffset((pageNum - 1)* resultsPerPage);
            crit.setLimit(resultsPerPage);
            result = ScarabUserImplPeer.doSelect(crit);

            // if there are results, sort the result set
            if (totalResultSize > 0 && resultsPerPage > 0)
            {

                paginated = new ScarabPaginatedList(result, totalResultSize,
                                                    pageNum,
                                                    resultsPerPage);
            }
            else 
            {
                paginated = new ScarabPaginatedList();
            }
        
        return paginated;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public List getUsers(String firstName, String lastName, 
                         String username, String email, IssueType issueType)
        throws TorqueException
    {
        List result = null;
        Serializable[] keys = {this, GET_USERS, firstName, lastName, 
                               username, email, issueType};
        Object obj = ScarabCache.get(keys); 
        if (obj == null) 
        {
            ScarabUser[] eligibleUsers = getUsers(getUserPermissions(issueType));
            if (eligibleUsers == null || eligibleUsers.length == 0) 
            {
                result = Collections.EMPTY_LIST;
            }
            else 
            {
                List userIds = new ArrayList();
                for (int i = 0; i < eligibleUsers.length; i++)
                {
                    userIds.add(eligibleUsers[i].getUserId());
                }
                Criteria crit = new Criteria();
                crit.addIn(ScarabUserImplPeer.USER_ID, userIds);
                
                if (firstName != null)
                {
                    crit.add(ScarabUserImplPeer.FIRST_NAME, 
                             addWildcards(firstName), Criteria.LIKE);
                }
                if (lastName != null)
                {
                    crit.add(ScarabUserImplPeer.LAST_NAME, 
                             addWildcards(lastName), Criteria.LIKE);
                }
                if (username != null)
                {
                    crit.add(ScarabUserImplPeer.LOGIN_NAME, 
                             addWildcards(username), Criteria.LIKE);
                }
                if (email != null)
                {
                    crit.add(ScarabUserImplPeer.EMAIL, addWildcards(email), 
                             Criteria.LIKE);
                }
                result = ScarabUserImplPeer.doSelect(crit);
            }
            ScarabCache.put(result, keys);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void setParent(Module v)
        throws TorqueException
    {
        super.setModuleRelatedByParentId(v);
        // setting the name to be null so that 
        // it gets rebuilt with the new information
        setName(null);
        resetAncestors();
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public Module getParent()
        throws TorqueException
    {
        Module parent = super.getModuleRelatedByParentId();

        // The top level module has itself as parent.
        // Return null in this case, to avoid endless loops.
        if (this.getModuleId() == parent.getModuleId())
        {
            parent = null;
        }
        return parent;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void setParentId(Integer id)
        throws TorqueException
    {
        super.setParentId(id);
        // setting the name to be null so that 
        // it gets rebuilt with the new information
        setName(null);
        resetAncestors();
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public List getRModuleIssueTypes()
        throws TorqueException
    {
        return super.getRModuleIssueTypes("preferredOrder","asc");
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public int getIssueCount(ScarabUser user, AttributeOption attributeOption)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();

        Integer attributeId = attributeOption.getAttributeId();
        Integer optionId    = attributeOption.getOptionId();

        crit.add(AttributeValuePeer.ATTRIBUTE_ID, attributeId);
        crit.add(AttributeValuePeer.OPTION_ID,optionId);
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.MOVED, 0);
        crit.add(IssuePeer.DELETED, 0);
        crit.add(IssuePeer.ID_COUNT, 0, SqlEnum.GREATER_THAN);
        crit.addJoin(AttributeValuePeer.ISSUE_ID, IssuePeer.ISSUE_ID);
        crit.add(AttributeValuePeer.DELETED,0);
        int count = AttributeValuePeer.count(crit);
        return count;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public int getIssueCount(ScarabUser user)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.DELETED,0);
        crit.add(IssuePeer.MOVED,0);
        crit.add(IssuePeer.ID_COUNT, 0, SqlEnum.GREATER_THAN);
        int count = IssuePeer.count(crit);
        return count;
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public List getRModuleAttributes(Criteria crit)
        throws TorqueException
    {
        return super.getRModuleAttributes(crit);
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public List getRModuleOptions(Criteria crit)
        throws TorqueException
    {
        crit.addJoin(RModuleOptionPeer.OPTION_ID, 
                     AttributeOptionPeer.OPTION_ID)
            .add(AttributeOptionPeer.DELETED, false);
        return super.getRModuleOptions(crit);
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public List getDuplicatesByNameAndParent(String realName, Integer parentId) throws TorqueException{
    	
    	final Criteria crit = new Criteria();
        crit.add(ScarabModulePeer.MODULE_NAME, realName);
        crit.add(ScarabModulePeer.PARENT_ID, parentId);
        return ScarabModulePeer.doSelect(crit);
        
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void save(final Connection dbCon) 
        throws TorqueException
    {
        // if new, make sure the code has a value.
        if (isNew())
        {

            List result;
            try {
                result = getDuplicatesByNameAndParent(getRealName(), getParentId());
            }
            catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
            if (result.size() > 0)
            {
                throw new ScarabLocalizedTorqueException(
                        new ScarabException(
                                L10NKeySet.ExceptionModuleAllreadyExists,
                        getRealName(), 
                        getParent().getName()));
            }

            final String code = getCode();
            if (code == null || code.length() == 0)
            {
                if (getParentId().equals(ROOT_ID))
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionTopLevelModuleWithoutCode));
                }

                try
                {
                    setCode(getParent().getCode());
                }
                catch (Exception e)
                {
                    throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionCantPropagateModuleCode, e));
                }
            }

            // need to do this before the relationship save below
            // in order to set the moduleid for the new module.
            super.save(dbCon);
            try
            {
                dbCon.commit();
            }
            catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
            
            if (getOwnerId() == null) 
            {
                throw new ScarabLocalizedTorqueException(new  ScarabException(L10NKeySet.ExceptionSaveNeedsOwner));
            }
            // grant the ower of the module the Project Owner role
            try
            {
                final User user = ScarabUserManager.getInstance(getOwnerId());
 
                final Role role = TurbineSecurity.getRole(PROJECT_OWNER_ROLE);
                grant (user, role);
                setInitialAttributesAndIssueTypes();
            }
            catch (Exception e)
            {
                throw new ScarabLocalizedTorqueException(new ScarabException(L10NKeySet.ExceptionGeneric, e));
            }
        }
        else
        {
            super.save(dbCon);
        }
        
        // clear out the cache beause we want to make sure that
        // things get updated properly.
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public List getNotDeletedModuleReports() 
        throws TorqueException
    {
        return ReportManager.getManager().getNotDeletedModuleReports(this);
    }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
public ScarabUser getCreator() throws TorqueException
    {
        Integer id = this.getCreatorId();
        ScarabUser user = ScarabUserManager.getInstance(id);
        return user;
    }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
public ScarabUser getReceiver() throws TorqueException
    {
        Integer id = this.getReceiverId();
        ScarabUser user = ScarabUserManager.getInstance(id);
        return user;
    }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
public void delete() throws TorqueException
    {
        Criteria crit = new Criteria();
        crit
                .add(NotificationStatusPeer.ACTIVITY_ID, this
                        .getActivityId());
        crit.add(NotificationStatusPeer.CREATOR_ID, this.getCreatorId());
        crit.add(NotificationStatusPeer.RECEIVER_ID, this.getReceiverId());
        NotificationStatusPeer.doDelete(crit);
    }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
public void markDeleted() throws TorqueException
    {
        this.setStatus(MARK_DELETED);
        this.setChangeDate(new Date());
        this.save();
    }
            
// in java/org/tigris/scarab/om/Transition.java
public boolean isRequiredIf(Integer optionID) throws TorqueException
    {
        Condition cond = new Condition();
        cond.setAttributeId(null);
        cond.setOptionId(optionID);
        cond.setModuleId(null);
        cond.setIssueTypeId(null);
        cond.setTransitionId(this.getTransitionId());
        return this.getConditions().contains(cond);
    }
            
// in java/org/tigris/scarab/om/Transition.java
public List<Condition> getConditions() throws TorqueException
    {
    	List<Condition> conds = (List<Condition>)TransitionManager.getMethodResult().get(this, "getConditions");
    	if (conds == null)
    	{
        	conds = super.getConditions();
        	TransitionManager.getMethodResult().put(conds, this, "getConditions");
    	}
    	return conds;
    }
            
// in java/org/tigris/scarab/om/Transition.java
public void setConditionsArray(Integer aOptionId[], Integer operator) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.ATTRIBUTE_ID, null);
        crit.add(ConditionPeer.MODULE_ID, null);
        crit.add(ConditionPeer.ISSUE_TYPE_ID, null);
        crit.add(ConditionPeer.TRANSITION_ID, this.getTransitionId());
        ConditionPeer.doDelete(crit);
        this.getConditions().clear();
        ConditionManager.clear();
        if (aOptionId != null)
        {
	        for (int i=0; i<aOptionId.length; i++)
	        {
	            if (aOptionId[i].intValue() != 0)
	            {
		            Condition cond = new Condition();
		            cond.setTransitionId(this.getTransitionId());
		            cond.setOptionId(aOptionId[i]);
		            cond.setAttributeId(null);
		            cond.setModuleId(null);
		            cond.setIssueTypeId(null);
		            cond.setOperator(operator);
		            this.addCondition(cond);
		            cond.save();
	            }
	        }
        }
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public IssueType getTemplateIssueType()
        throws TorqueException, ScarabException
    {
        if (templateIssueType == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.PARENT_ID, getIssueTypeId());
            final List results = IssueTypePeer.doSelect(crit);
            if (results.isEmpty())
            {
                throw new ScarabException(L10NKeySet.ExceptionTemplateTypeForIssueType);
            }
            else
            {
                templateIssueType = (IssueType)results.get(0);
            }
        }
        return templateIssueType;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public IssueType getIssueTypeForTemplateType()
        throws TorqueException
    {
        if (parentIssueType == null) 
        {        
            parentIssueType = getIssueTypeRelatedByParentId();
        }
        return parentIssueType;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public Integer getTemplateId()
        throws TorqueException, ScarabException
    {
        return getTemplateIssueType().getIssueTypeId();
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean hasIssues()
        throws TorqueException, DataSetException
    {
        return hasIssues((Module) null);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public String getDisplayName(Module module)
        throws TorqueException
    {
        String moduleName = module.getRModuleIssueType(this).getDisplayName();
        String displayName = getName();
        if (!moduleName.equals(displayName))
        {
            displayName = moduleName +" (" + displayName + ")";
        }
        return displayName;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean hasIssues(Module module)
        throws TorqueException, DataSetException
    {
        Criteria crit = new Criteria();
        crit.add(IssuePeer.TYPE_ID, getIssueTypeId());
        if (module != null)
        {
            crit.add(IssuePeer.MODULE_ID, module.getModuleId());
        }
        return (IssuePeer.count(crit) > 0);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public static IssueType getInstance(final String issueTypeName)
        throws TorqueException,ScarabException
    {
        IssueType result = null;
        Object obj = ScarabCache.get(ISSUE_TYPE, GET_INSTANCE, issueTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(IssueTypePeer.NAME, issueTypeName);
            final List issueTypes = IssueTypePeer.doSelect(crit);
            if(issueTypes == null || issueTypes.size() == 0)
            {
                throw new ScarabException(L10NKeySet.ExceptionInvalidIssueType,
                                          issueTypeName);
            }
            result = (IssueType)issueTypes.get(0);
            ScarabCache.put(result, ISSUE_TYPE, GET_INSTANCE, issueTypeName);
        }
        else 
        {
            result = (IssueType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public IssueType copyIssueType()
        throws TorqueException, ScarabException
    {
        final IssueType newIssueType = new IssueType();
        newIssueType.setName(getName() + " (copy)");
        newIssueType.setDescription(getDescription());
        newIssueType.setParentId(ScarabConstants.INTEGER_0);
        newIssueType.save();
        final Integer newId = newIssueType.getIssueTypeId();

        // Copy template type
        final IssueType template = IssueTypePeer
              .retrieveByPK(getTemplateId());
        final IssueType newTemplate = new IssueType();
        newTemplate.setName(template.getName());
        newTemplate.setParentId(newId);
        newTemplate.save();

        // Copy user attributes
        final List userRIAs = getRIssueTypeAttributes(false, USER);
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            final RIssueTypeAttribute newUserRia = userRia.copyRia();
            newUserRia.setIssueTypeId(newId);
            newUserRia.save();
        }

        // Copy attribute groups
        final List attrGroups = getAttributeGroups(false);
        for (int i = 0; i<attrGroups.size(); i++)
        {
            final AttributeGroup group = (AttributeGroup)attrGroups.get(i);
            final AttributeGroup newGroup = group.copyGroup();
            newGroup.setIssueTypeId(newId);
            newGroup.save();

            // add attributes
            final List attrs = group.getAttributes();
            if (attrs != null)
            {
                for (int j=0; j<attrs.size(); j++)
                {
                    // save attribute-attribute group maps
                    final Attribute attr = (Attribute)attrs.get(j);
                    final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                    final RAttributeAttributeGroup newRaag = new RAttributeAttributeGroup();
                    newRaag.setAttributeId(raag.getAttributeId());
                    newRaag.setOrder(raag.getOrder());
                    newRaag.setGroupId(newGroup.getAttributeGroupId());
                    newRaag.save();

                    // save attribute-issueType maps
                    final RIssueTypeAttribute ria = getRIssueTypeAttribute(attr);
                    final RIssueTypeAttribute newRia = ria.copyRia();
                    newRia.setIssueTypeId(newId);
                    newRia.save();

                    // save options
                    final List rios = getRIssueTypeOptions(attr, false);
                    if (rios != null)
                    {
                        for (int k=0; k<rios.size(); k++)
                        {
                            final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                            final RIssueTypeOption newRio = rio.copyRio();
                            newRio.setIssueTypeId(newId);
                            newRio.save();
                        }
                    }
                }
            }
        }

        // add workflow 
        WorkflowFactory.getInstance().copyIssueTypeWorkflows(this, newIssueType);

        return newIssueType;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public void deleteModuleMappings(final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                 getIssueTypeId());
        final List rmits = RModuleIssueTypePeer.doSelect(crit);
        for (int i=0; i<rmits.size(); i++)
        {
            final RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
            rmit.delete(user);
        }
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public void createDefaultGroups()
        throws TorqueException
    {
        AttributeGroup ag = createNewGroup();
        ag.setOrder(1);
        ag.setDedupe(true);
        ag.setDescription(null);
        ag.save();
        AttributeGroup ag2 = createNewGroup();
        ag2.setOrder(3);
        ag2.setDedupe(false);
        ag2.setDescription(null);
        ag2.save();
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getAttributeGroups(Module module)
        throws TorqueException
    {
        return getAttributeGroups(module, false);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getAttributeGroups(boolean activeOnly)
        throws TorqueException
    {
        return getAttributeGroups(null, activeOnly);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getAttributeGroups(Module module, boolean activeOnly)
        throws TorqueException
    {
        List groups = null;
        Boolean activeBool = activeOnly ? Boolean.TRUE : Boolean.FALSE;
        Object obj = getMethodResult().get(this, GET_ATTRIBUTE_GROUPS,
                                           module, activeBool);
        if (obj == null)
        {
            Criteria crit = new Criteria()
                .add(AttributeGroupPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .addAscendingOrderByColumn(AttributeGroupPeer.PREFERRED_ORDER);
            if (activeOnly)
            {
                crit.add(AttributeGroupPeer.ACTIVE, true);
            }
            if (module != null)
            {
                crit.add(AttributeGroupPeer.MODULE_ID, module.getModuleId());
            }
            else
            {
                // TODO Change this to be crit.add(AttributeGroupPeer.MODULE_ID, Criteria.ISNULL) when torque is fixed
                crit.add(AttributeGroupPeer.MODULE_ID,
                         (Object)(AttributeGroupPeer.MODULE_ID + " IS NULL"),
                         Criteria.CUSTOM);
            }
            groups = AttributeGroupPeer.doSelect(crit);
            getMethodResult().put(groups, this, GET_ATTRIBUTE_GROUPS,
                                  module, activeBool);
        }
        else
        {
            groups = (List)obj;
        }
        return groups;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public AttributeGroup createNewGroup()
        throws TorqueException
    {
        return createNewGroup(null);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public AttributeGroup createNewGroup(Module module)
        throws TorqueException
    {
        List groups = getAttributeGroups(module, false);
        AttributeGroup ag = new AttributeGroup();

        // Make default group name 'new attribute group' 
        ag.setName(Localization.getString("ScarabBundle",
                ScarabConstants.DEFAULT_LOCALE, "NewAttributeGroup"));
        ag.setActive(true);
        ag.setIssueTypeId(getIssueTypeId());
        if (module != null)
        {
            ag.setModuleId(module.getModuleId());
        }
        if (groups.size() == 0)
        {
            ag.setDedupe(true);
            ag.setOrder(groups.size() +1);
        }
        else 
        {
            ag.setDedupe(false);
            ag.setOrder(groups.size() +2);
        }
        ag.save();
        groups.add(ag);
        return ag;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public int getDedupeSequence()
        throws TorqueException
    {
        return getDedupeSequence(null);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
int getDedupeSequence(Module module)
        throws TorqueException
    {
        List groups = getAttributeGroups(module, false);
        int sequence = groups.size() + 1;
        for (int i = 1; i <= groups.size(); i++)
        {
            int order;
            int previousOrder;
            try
            {
                order = ((AttributeGroup) groups.get(i)).getOrder();
                previousOrder = ((AttributeGroup) groups.get(i - 1)).getOrder();
            }
            catch (Exception e)
            {
                Log.get().warn("Error accessing dedupe sequence for issue "
                               + "type '" + this + '\'', e);
                return sequence;
            }

            if (order != previousOrder + 1)
            {
                sequence = order - 1;
                break;
            }
        }
        return sequence;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getRIssueTypeAttributes(boolean activeOnly)
        throws TorqueException
    {
        return getRIssueTypeAttributes(activeOnly, "all");
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getRIssueTypeAttributes(boolean activeOnly,
                                        String attributeType)
        throws TorqueException
    {
        List rias = null;
        Boolean activeBool = (activeOnly ? Boolean.TRUE : Boolean.FALSE);
        Object obj = getMethodResult().get(this, GET_R_ISSUETYPE_ATTRIBUTES, 
                                           activeBool, attributeType); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, 
                     getIssueTypeId());
            crit.addAscendingOrderByColumn(
                RIssueTypeAttributePeer.PREFERRED_ORDER);
            
            if (activeOnly)
            {
                crit.add(RIssueTypeAttributePeer.ACTIVE, true);
            }
            
            if (USER.equals(attributeType))
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY);
                crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                         RIssueTypeAttributePeer.ATTRIBUTE_ID); 
            }
            else if (NON_USER.equals(attributeType))
            {
                crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                         RIssueTypeAttributePeer.ATTRIBUTE_ID); 
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY,
                         Criteria.NOT_EQUAL);
            }
            
            rias = RIssueTypeAttributePeer.doSelect(crit); 
            getMethodResult().put(rias, this, GET_R_ISSUETYPE_ATTRIBUTES, 
                                  activeBool, attributeType);
        }
        else 
        {
            rias = (List)obj;
        }
        return rias;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getAttributes(String attributeType)
        throws TorqueException
    {
        ArrayList attrs = new ArrayList();
        List rias = getRIssueTypeAttributes(true, attributeType);
        for (int i=0; i<rias.size(); i++)
        {
            attrs.add(((RIssueTypeAttribute)rias.get(i)).getAttribute());
        }
        return attrs;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public RIssueTypeAttribute addRIssueTypeAttribute(Attribute attribute)
        throws TorqueException
    {
        String attributeType = null;
        attributeType = (attribute.isUserAttribute() ? USER : NON_USER);

        RIssueTypeAttribute ria = new RIssueTypeAttribute();
        ria.setIssueTypeId(getIssueTypeId());
        ria.setAttributeId(attribute.getAttributeId());
        ria.setOrder(getLastAttribute(attributeType) + 1);
        ria.save();
        getRIssueTypeAttributes(false, attributeType).add(ria);
        return ria;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public RIssueTypeAttribute getRIssueTypeAttribute(Attribute attribute)
        throws TorqueException
    {
        RIssueTypeAttribute ria = null;
        List rias = null;
        if (attribute.isUserAttribute())
        {
            rias = getRIssueTypeAttributes(false, USER);
        }
        else
        {
            rias = getRIssueTypeAttributes(false, NON_USER);
        }
        Iterator i = rias.iterator();
        while (i.hasNext())
        {
            RIssueTypeAttribute tempRia = (RIssueTypeAttribute)i.next();
            if (tempRia.getAttribute().equals(attribute))
            {
                ria = tempRia;
                break;
            }
        }
        return ria;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getUserAttributes()
        throws TorqueException
    {
        return getUserAttributes(true);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getUserAttributes(boolean activeOnly)
        throws TorqueException
    {
        List rIssueTypeAttributes = getRIssueTypeAttributes(activeOnly, USER);
        List userAttributes = new ArrayList();

        for (int i=0; i<rIssueTypeAttributes.size(); i++)
        {
            Attribute att = ((RIssueTypeAttribute)rIssueTypeAttributes.get(i)).getAttribute();
            userAttributes.add(att);
        }
        return userAttributes;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public int getLastAttribute(String attributeType)
        throws TorqueException
    {
        List itAttributes = getRIssueTypeAttributes(false, attributeType);
        int last = 0;

        for (int i=0; i<itAttributes.size(); i++)
        {
               int order = ((RIssueTypeAttribute) itAttributes.get(i))
                         .getOrder();
               if (order > last)
               {
                   last = order;
               }
        }
        return last;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public int getLastAttributeOption(Attribute attribute)
        throws TorqueException
    {
        List issueTypeOptions = getRIssueTypeOptions(attribute);
        int last = 0;

        for (int i=0; i<issueTypeOptions.size(); i++)
        {
               int order = ((RIssueTypeOption) issueTypeOptions.get(i))
                         .getOrder();
               if (order > last)
               {
                   last = order;
               }
        }
        return last;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public RIssueTypeOption addRIssueTypeOption(AttributeOption option)
        throws TorqueException
    {
        RIssueTypeOption rio = new RIssueTypeOption();
        rio.setIssueTypeId(getIssueTypeId());
        rio.setOptionId(option.getOptionId());
        rio.setOrder(getLastAttributeOption(option.getAttribute()) + 1);
        rio.save();
        getRIssueTypeOptions(option.getAttribute(), false).add(rio);
        return rio;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getRIssueTypeOptions(Attribute attribute)
        throws TorqueException
    {
        return getRIssueTypeOptions(attribute, true);
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getRIssueTypeOptions(Attribute attribute, boolean activeOnly)
        throws TorqueException
    {
        List allRIssueTypeOptions = null;
        allRIssueTypeOptions = getAllRIssueTypeOptions(attribute);

        if (allRIssueTypeOptions != null)
        {
            if (activeOnly)
            {
                List activeRIssueTypeOptions =
                    new ArrayList(allRIssueTypeOptions.size());
                for (int i=0; i<allRIssueTypeOptions.size(); i++)
                {
                    RIssueTypeOption rio =
                        (RIssueTypeOption)allRIssueTypeOptions.get(i);
                    if (rio.getActive())
                    {
                        activeRIssueTypeOptions.add(rio);
                    }
                }
                allRIssueTypeOptions =  activeRIssueTypeOptions;
            }
        }
        return allRIssueTypeOptions;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
private List getAllRIssueTypeOptions(Attribute attribute)
        throws TorqueException
    {
        List rIssueTypeOpts;
        Object obj = ScarabCache.get(this, GET_ALL_R_ISSUETYPE_OPTIONS, 
                                     attribute); 
        if (obj == null) 
        {
            List options = attribute.getAttributeOptions(false);
            Integer[] optIds = null;
            if (options == null)
            {
                optIds = new Integer[0];
            }
            else
            {
                optIds = new Integer[options.size()];
            }
            for (int i=optIds.length-1; i>=0; i--)
            {
                optIds[i] = ((AttributeOption)options.get(i)).getOptionId();
            }
            
            if (optIds.length > 0)
            { 
                Criteria crit = new Criteria();
                crit.add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId());
                crit.addIn(RIssueTypeOptionPeer.OPTION_ID, optIds);
                crit.addJoin(RIssueTypeOptionPeer.OPTION_ID, AttributeOptionPeer.OPTION_ID);
                crit.addAscendingOrderByColumn(RIssueTypeOptionPeer.PREFERRED_ORDER);
                crit.addAscendingOrderByColumn(AttributeOptionPeer.OPTION_NAME);
                rIssueTypeOpts = RIssueTypeOptionPeer.doSelect(crit);
            }
            else
            {
                rIssueTypeOpts = new ArrayList(0);
            }
            ScarabCache.put(rIssueTypeOpts, this, GET_ALL_R_ISSUETYPE_OPTIONS, 
                            attribute);
        }
        else 
        {
            rIssueTypeOpts = (List)obj;
        }
        return rIssueTypeOpts;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public RIssueTypeOption getRIssueTypeOption(AttributeOption option)
        throws TorqueException
    {
        RIssueTypeOption rio = null;
        List rios = getRIssueTypeOptions(option.getAttribute(), false);
        Iterator i = rios.iterator();
        while (i.hasNext())
        {
            rio = (RIssueTypeOption)i.next();
            if (rio.getAttributeOption().equals(option))
            {
                break;
            }
        }

        return rio;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getAvailableAttributes(String attributeType)
        throws TorqueException
    {
        List allAttributes = AttributePeer.getAttributes(attributeType);
        List availAttributes = new ArrayList();
        List rIssueTypeAttributes = getRIssueTypeAttributes(false,
                                                            attributeType);
        List attrs = new ArrayList();
        for (int i=0; i<rIssueTypeAttributes.size(); i++)
        {
            attrs.add(
               ((RIssueTypeAttribute) rIssueTypeAttributes.get(i)).getAttribute());
        }
        for (int i=0; i<allAttributes.size(); i++)
        {
            Attribute att = (Attribute)allAttributes.get(i);
            if (!attrs.contains(att))
            {
                availAttributes.add(att);
            }
        }
        return availAttributes;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getAvailableAttributeOptions(Attribute attribute)
        throws TorqueException
    {
        List rIssueTypeOptions = getRIssueTypeOptions(attribute, false);
        List issueTypeOptions = new ArrayList();
        if (rIssueTypeOptions != null)
        {
            for (int i=0; i<rIssueTypeOptions.size(); i++)
            {
                issueTypeOptions.add(
                   ((RIssueTypeOption) rIssueTypeOptions.get(i)).getAttributeOption());
            }
        }

        List allOptions = attribute.getAttributeOptions(false);
        List availOptions = new ArrayList();

        for (int i=0; i<allOptions.size(); i++)
        {
            AttributeOption option = (AttributeOption)allOptions.get(i);
            if (!issueTypeOptions.contains(option))
            {
                availOptions.add(option);
            }
        }
        return availOptions;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getMatchingAttributeValuesList(Module oldModule, Module newModule, 
                                               IssueType newIssueType)
          throws TorqueException
    {
        List matchingAttributes = new ArrayList();
        List srcActiveAttrs = getActiveAttributes(oldModule);
        List destActiveAttrs = newIssueType.getActiveAttributes(newModule);
        for (int i = 0; i<srcActiveAttrs.size(); i++)
        {
            Attribute attr = (Attribute)srcActiveAttrs.get(i);
                
            if (destActiveAttrs.contains(attr))
            {
                matchingAttributes.add(attr);
            } 
        }
        return matchingAttributes;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getOrphanAttributeValuesList(Module oldModule, Module newModule, 
                                             IssueType newIssueType)
          throws TorqueException
    {
        List orphanAttributes = new ArrayList();
        List srcActiveAttrs = getActiveAttributes(oldModule);
        List destActiveAttrs = newIssueType.getActiveAttributes(newModule);
        for (int i = 0; i<srcActiveAttrs.size(); i++)
        {
            Attribute attr = (Attribute)srcActiveAttrs.get(i);
            if (!destActiveAttrs.contains(attr))
            {
                orphanAttributes.add(attr);
            }
        }
        return orphanAttributes;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean isSystemDefined()
        throws TorqueException
    {
        boolean systemDefined = false;
        String name = getName();
        if (name != null)
        {
            systemDefined = "system".equalsIgnoreCase(SYSTEM_CONFIG.getProperty(name));
        }
        return systemDefined;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public Attribute getDefaultTextAttribute(Module module)
        throws TorqueException
    {
        Attribute result = null;
        Object obj = ScarabCache.get(this, GET_DEFAULT_TEXT_ATTRIBUTE); 
        if (obj == null) 
        {        
            // get related RMAs
            Criteria crit = new Criteria()
                .add(RModuleAttributePeer.MODULE_ID, 
                     module.getModuleId());
            crit.addAscendingOrderByColumn(
                RModuleAttributePeer.PREFERRED_ORDER);
            List rmas = getRModuleAttributes(crit);
            
            // the code to find the correct attribute could be quite simple by
            // looping and calling RMA.isDefaultText().  The code from
            // that method can be restructured here to more efficiently
            // answer this question.
            Iterator i = rmas.iterator();
            while (i.hasNext()) 
            {
                RModuleAttribute rma = (RModuleAttribute)i.next();
                if (rma.getDefaultTextFlag()) 
                {
                    result = rma.getAttribute();
                    break;
                }
            }
            
            if (result == null) 
            {
                // locate the highest ranked text attribute
                i = rmas.iterator();
                while (i.hasNext()) 
                {
                    RModuleAttribute rma = (RModuleAttribute)i.next();
                    Attribute testAttr = rma.getAttribute();
                    if (testAttr.isTextAttribute() && 
                         getAttributeGroup(module, testAttr).getActive()) 
                    {
                        result = testAttr;
                        break;
                    }
                }
            }
            ScarabCache.put(result, this, GET_DEFAULT_TEXT_ATTRIBUTE);
        }
        else 
        {
            result = (Attribute)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getQuickSearchAttributes(Module module)
        throws TorqueException
    {
        List attributes = null;
        Object obj = ScarabCache.get(this, GET_QUICK_SEARCH_ATTRIBUTES, 
                                     module); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(3)
                .add(RModuleAttributePeer.QUICK_SEARCH, true);
            addOrderByClause(crit, module);
            attributes = getAttributes(crit);
            ScarabCache.put(attributes, this, GET_QUICK_SEARCH_ATTRIBUTES, 
                            module);
        }
        else 
        {
            attributes = (List)obj;
        }
        return attributes;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
private List getAttributes(final Criteria criteria)
        throws TorqueException
    {
        final List moduleAttributes = getRModuleAttributes(criteria);
        final List attributes = new ArrayList(moduleAttributes.size());
        for (int i=0; i<moduleAttributes.size(); i++)
        {
            attributes.add(
               ((RModuleAttribute) moduleAttributes.get(i)).getAttribute());
        }
        return attributes;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean canCreateIssueInScope(ScarabUser user, Module module) throws TorqueException, ScarabException
    {
        //[HD first check, if user has IssueCreate permission in this module
        boolean isPermissionGranted = user.hasPermission(ScarabSecurity.ISSUE__ENTER, module);
        
        if(isPermissionGranted)
        {
            List requiredAttributes = getRequiredAttributes(module);
            Iterator iter = requiredAttributes.iterator();
            while(iter.hasNext())
            {
                Attribute attribute = (Attribute)iter.next();
                Workflow workflow = WorkflowFactory.getInstance();
                if(attribute.isOptionAttribute())
                {
                    boolean canDoPartial = workflow.canMakeTransitionsFrom(user, this, attribute, null);
                    if(!canDoPartial)
                    {
                        isPermissionGranted = false;
                        break;
                    }
                }
            }
        }
        return isPermissionGranted;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public boolean canCreateAttributeInScope(ScarabUser user, Module module, Attribute attribute) throws TorqueException, ScarabException
    {
        boolean result = true;
        Workflow workflow = WorkflowFactory.getInstance();
        if(attribute.isOptionAttribute())
        {
            result = workflow.canMakeTransitionsFrom(user, this, attribute, null);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List getRequiredAttributes(Module module)
        throws TorqueException
    {

        List attributes = null;
        Object obj = ScarabCache.get(this, GET_REQUIRED_ATTRIBUTES, 
                                     module); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(3)
                .add(RModuleAttributePeer.REQUIRED, true);
            crit.add(RModuleAttributePeer.ACTIVE, true);
            addOrderByClause(crit, module);
            List temp =  getAttributes(crit);
            List requiredAttributes  = new ArrayList();
            for (int i=0; i <temp.size(); i++)
            {
                Attribute att = (Attribute)temp.get(i);
                AttributeGroup group = getAttributeGroup(module, att);
                if (group != null && group.getActive())
                {
                    requiredAttributes.add(att);
                }
            }
            attributes = requiredAttributes;
            ScarabCache.put(attributes, this, GET_REQUIRED_ATTRIBUTES, 
                            module);
        }
        else 
        {
            attributes = (List)obj;
        }
        return attributes;

    }
            
// in java/org/tigris/scarab/om/IssueType.java
public List<Attribute> getActiveAttributes(final Module module)
        throws TorqueException
    {
        List attributes = null;
        Object obj = ScarabCache.get(this, GET_ACTIVE_ATTRIBUTES, module);
        if (obj == null)
        {
            final Criteria crit = new Criteria(2);
            crit.add(RModuleAttributePeer.ACTIVE, true);
            addOrderByClause(crit, module);
            attributes = getAttributes(crit);
            ScarabCache.put(attributes, this, GET_ACTIVE_ATTRIBUTES, 
                            module);
        }
        else
        {
            attributes = (List)obj;
        }
        return attributes;
    }
            
// in java/org/tigris/scarab/om/IssueType.java
private AttributeGroup getAttributeGroup(Module module, 
                                             Attribute attribute)
        throws TorqueException
    {
        AttributeGroup group = null;
        Object obj = ScarabCache.get(this, GET_ATTRIBUTE_GROUP, 
                                     module, attribute); 
        if (obj == null)
        {
            Criteria crit = new Criteria()
                .add(AttributeGroupPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(AttributeGroupPeer.MODULE_ID, 
                     module.getModuleId())
                .addJoin(RAttributeAttributeGroupPeer.GROUP_ID, 
                   AttributeGroupPeer.ATTRIBUTE_GROUP_ID)
                .add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId());
            List results = AttributeGroupPeer.doSelect(crit);
            if (results.size() > 0)
            {
                group = (AttributeGroup)results.get(0);
                ScarabCache.put(group, this, GET_ATTRIBUTE_GROUP, 
                                module, attribute);
            }
        }
        else 
        {
            group = (AttributeGroup)obj;
        }
        return group;
    }
            
// in java/org/tigris/scarab/om/RModuleAttributeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(RModuleAttributePeer.MODULE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/RModuleAttributeManager.java
public static final RModuleAttribute getInstance(Module module,  
        Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        SimpleKey[] keys = {
            SimpleKey.keyFor(module.getModuleId()),
            SimpleKey.keyFor(attribute.getAttributeId()),
            SimpleKey.keyFor(issueType.getIssueTypeId())
        };
        return getInstance(new ComboKey(keys));
    }
            
// in java/org/tigris/scarab/om/RModuleAttributeManager.java
public static final RModuleAttribute getInstance(Integer moduleId,  
        Integer attributeId, Integer issueTypeId)
        throws TorqueException
    {
        SimpleKey[] keys = {
            SimpleKey.keyFor(moduleId), 
            SimpleKey.keyFor(attributeId), 
            SimpleKey.keyFor(issueTypeId)
        };
        return getInstance(new ComboKey(keys));
    }
            
// in java/org/tigris/scarab/om/RModuleAttributeManager.java
static void removeInstanceFromCache(RModuleAttribute rma)
        throws TorqueException
    {
        RModuleAttributeManager thisManager = getManager();
        thisManager.removeInstanceImpl(rma.getPrimaryKey());
        List listeners = (List)thisManager.listenersMap
            .get(RModuleAttributePeer.MODULE_ID);
        thisManager.notifyListeners(listeners, rma, rma);
    }
            
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getSingleItemList(Module module, IssueType issueType,
                                            ScarabUser user)
        throws TorqueException
    {
        MITList list = getInstance();
        if (user != null) 
        {
            list.setScarabUser(user);
        }
        MITListItem item = MITListItemManager.getInstance();
        item.setModule(module);
        item.setIssueType(issueType);
        list.addMITListItem(item);
        return list;
    }
            
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getSingleModuleAllIssueTypesList(Module module,
                                                           ScarabUser user)
        throws TorqueException
    {
        MITList list = MITListManager.getInstance();
        list.setModifiable(false);
        list.setScarabUser(user);
        list.setName(Localization.format(ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         user.getLocale(),
                                         "AllIssueTypesCurrentModule", 
                                         module.getRealName()));
        
        MITListItem item = MITListItemManager.getInstance();
        item.setModule(module);
        item.setIssueTypeId(MITListItem.MULTIPLE_KEY);
        list.addMITListItem(item);
        return list;
    }
            
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getAllModulesAllIssueTypesList(ScarabUser user)
        throws TorqueException
    {
        MITList list = MITListManager.getInstance();
        list.setModifiable(false);
        list.setScarabUser(user);
        list.setName(Localization.getString(ScarabConstants.DEFAULT_BUNDLE_NAME,
                                      user.getLocale(),
                                      "AllModulesAndIssueTypes"));

        MITListItem item = MITListItemManager.getInstance();
        item.setModuleId(MITListItem.MULTIPLE_KEY);
        list.addMITListItem(item);
        item.setIssueTypeId(MITListItem.MULTIPLE_KEY);
        return list;
    }
            
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getAllModulesSingleIssueTypeList(IssueType issueType,
                                                           ScarabUser user)
        throws TorqueException
    {
        MITList list = MITListManager.getInstance();
        list.setModifiable(false);
        list.setScarabUser(user);
        list.setName(Localization.format(ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         user.getLocale(),
                                         "CurrentIssueTypeAllModules", 
                                         issueType.getName()));

        MITListItem item = MITListItemManager.getInstance();
        item.setModuleId(MITListItem.MULTIPLE_KEY);
        item.setIssueType(issueType);
        list.addMITListItem(item);
        return list;
    }
            
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getInstanceFromIssueList(List issues, 
                                                   ScarabUser user)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        
        if (user == null) 
        {
            throw new IllegalArgumentException("Null user is not allowed."); //EXCEPTION
        }
        
        MITList list = getInstance();
        list.setScarabUser(user);
        List dupeCheck = list.getMITListItems();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            MITListItem item = MITListItemManager.getInstance();
            item.setModule(issue.getModule());
            item.setIssueType(issue.getIssueType());
            if (!dupeCheck.contains(item)) 
            {
                list.addMITListItem(item);
            }
        }
        
        return list;
    }
            
// in java/org/tigris/scarab/om/MITListManager.java
public static MITList getInstanceByName(String name, ScarabUser user)
        throws TorqueException
    {
        MITList result = null;
        Criteria crit = new Criteria();
        crit.add(MITListPeer.NAME, name);
        crit.add(MITListPeer.ACTIVE, true);
        crit.add(MITListPeer.USER_ID, user.getUserId());
        List mitLists = MITListPeer.doSelect(crit);
        if (mitLists != null && !mitLists.isEmpty()) 
        {
            result = (MITList)mitLists.get(0);
            // it is not good if more than one active list has the 
            // same name (per user).  We could throw an exception here
            // but its possible the system can still function under
            // this circumstance, so just log it for now.
            Log.get().error("Multiple active lists exist with list name="
                            + name + " for user=" + user.getUserName() + 
                            "("+user.getUserId()+")");
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/IssueManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        // saving an issue object could affect some cached results, since it could be a move
        Serializable obj = (Serializable)om;
        getMethodResult().removeAll(obj, Issue.GET_MODULE_ATTRVALUES_MAP);
        getMethodResult().remove(obj, Issue.GET_USER_ATTRIBUTEVALUES);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/AttributeGroupManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttributeGroupPeer.MODULE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/ActivitySetPeer.java
public static ActivitySet retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        ActivitySet result = null;
        Object obj = ScarabCache.get(TRANSACTION_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseActivitySetPeer.retrieveByPK(pk);
            ScarabCache.put(result, TRANSACTION_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (ActivitySet)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/MITListItem.java
public int getIssueCount(ScarabUser user, AttributeOption attributeOption)
        throws TorqueException, ScarabException, DataSetException
    {
        Criteria crit = new Criteria();

        Integer attributeId = attributeOption.getAttributeId();
        Integer optionId    = attributeOption.getOptionId();

        crit.add(AttributeValuePeer.ATTRIBUTE_ID, attributeId);
        crit.add(AttributeValuePeer.OPTION_ID,optionId);
        crit.add(AttributeValuePeer.DELETED,0);
        crit.add(IssuePeer.MODULE_ID,getModuleId());
        crit.add(IssuePeer.TYPE_ID,this.getIssueTypeId());
        crit.add(IssuePeer.MOVED, 0);
        crit.add(IssuePeer.DELETED, 0);
        crit.addJoin(AttributeValuePeer.ISSUE_ID, IssuePeer.ISSUE_ID);

        int count = AttributeValuePeer.count(crit);
        return count;
    }
            
// in java/org/tigris/scarab/om/MITListItem.java
public String getAttributeDisplayName(final Attribute attribute) throws TorqueException
    {
        if (!isSingleIssueType())
        {
            // FIXME: we should in fact use isSingleModuleIssueType() here
            //        but the reference of multiple modules 
            //        is represented by moduleId == MULTIPE_KEY,
            //        which has the value of 0
            //        which is also the id of the global module
            //        probably null is a better value for MULTIPE_KEY
            throw new IllegalStateException(
               "method should not be called on an item " +
               "including issue types");
        }
        Module module = getModule();
        IssueType issueType = getIssueType();
        RModuleAttribute rma = module.getRModuleAttribute(attribute, issueType);
        String displayValue;
        
        // FIXME: When would the rma be null ? I got this error today, while performing a cross module
        //        query. But i couldn't find the cause.
        //        It may be related to an inconsistent submodule definition ...
        //        In order to debug this behaviour, i added a generic displayValue here. Now the NPE
        //        is away, but the generic displayValues don't appear either on the GUI. So whatever happens
        //        here, the associated items seem to be irrelevant on the GUI... To be further examined!
        if(rma != null)
        {
        	displayValue = rma.getDisplayValue();
        }
        else
        {
        	displayValue = "" + attribute.getName() + ":" + issueType.getName();
        }
        return displayValue;
    }
            
// in java/org/tigris/scarab/om/NotificationRule.java
public static NotificationRule createDefaultRule(Integer moduleId,
                                            Integer userId,
                                            Integer managerId,
                                            String activityType) throws TorqueException
    {
        NotificationRule rule = new NotificationRule();
        rule.setModuleId(moduleId);
        rule.setUserId(userId);
        rule.setActivityType(activityType);
        rule.setManagerId(managerId);

        // default settings.
        // currently hard coded. will later be
        // replaced by a default customization

        rule.setFilterState(true);   // enabled by default
        rule.setSendSelf(false);     // don't send to myself by default
        rule.setSendFailures(false); // don't notify me about failures by default
        rule.save();
        return rule;
    }
            
// in java/org/tigris/scarab/om/AttributeTypeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(AttributeTypePeer.ATTRIBUTE_TYPE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
public static boolean isNotificationEnabledFor(ScarabUser user, Issue issue, boolean isSelf, String activityType, ActivitySet activitySet) throws ScarabException, TorqueException
    {
        Integer userId   = user.getUserId();
        Module module    = issue.getModule();
        Integer moduleId = module.getModuleId();
        
        NotificationRule rule = getNotificationRule(moduleId, userId, activityType);
        boolean isEnabled;
        if(isSelf)
        {
            isEnabled = rule.getSendSelf();
        }
        else
        {
            if(issue.isSealed() && !activitySet.hasTransitionSealed())
            {
                isEnabled = false; // Do not send notifications to other users when Issue is "closed"
            }
            else
            {
                isEnabled = rule.getFilterState();
            }
        }
        
        if(isEnabled)
        {
            Notification notification = new Notification(user, issue);
            isEnabled = notification.sendConditionsMatch();
        }
        return isEnabled;
    }
            
// in java/org/tigris/scarab/om/RIssueTypeOption.java
public void delete(final ScarabUser user, final Module module)
         throws TorqueException, ScarabException
    {                
        if (user.hasPermission(ScarabSecurity.DOMAIN__EDIT, module))
        {
            final List rios = getIssueType().getRIssueTypeOptions(
                                      getAttributeOption().getAttribute(), false);
            final Criteria c = new Criteria()
                .add(RIssueTypeOptionPeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
            RIssueTypeOptionPeer.doDelete(c);
            rios.remove(this);
            if (rios.size() > 0)
            {
                // Correct the ordering of the remaining options
                final ArrayList optIds = new ArrayList();
                for (int i=0; i<rios.size();i++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)rios.get(i);
                    optIds.add(rio.getOptionId());
                }
                final Criteria c2 = new Criteria()
                    .addIn(RIssueTypeOptionPeer.OPTION_ID, optIds)
                    .add(RIssueTypeOptionPeer.PREFERRED_ORDER, getOrder(), 
                         Criteria.GREATER_THAN);
                final List adjustRios = RIssueTypeOptionPeer.doSelect(c2);
                for (int j=0; j<adjustRios.size();j++)
                {
                    final RIssueTypeOption rio = (RIssueTypeOption)adjustRios.get(j);
                    rio.setOrder(rio.getOrder() -1);
                    rio.save();
                }
            }
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/RIssueTypeOption.java
public RIssueTypeOption copyRio()
         throws TorqueException
    {                
        RIssueTypeOption rio = new RIssueTypeOption();
        rio.setIssueTypeId(getIssueTypeId());
        rio.setOptionId(getOptionId());
        rio.setActive(getActive());
        rio.setOrder(getOrder());
        rio.setWeight(getWeight());
        return rio;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public Issue getNewIssue(IssueType issueType)
        throws TorqueException
    {
        Issue issue = Issue.getNewInstance(this, issueType);
        issue.setDeleted(false);
        return issue;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public synchronized List getAncestors()
        throws TorqueException
    {
        if (parentModules == null)
        {
            parentModules = new ArrayList();
            Module parent = getParent();
             if (parent != null && !parent.getModuleId().equals(ROOT_ID) && !isEndlessLoop(parent))
            {
                addAncestors(parent);
            }
        }
        return parentModules;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
private void addAncestors(Module module)
        throws TorqueException
    {
        if (!module.getParentId().equals(ROOT_ID))
        {
            addAncestors(module.getParent());
        }
        parentModules.add(module);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean isEndlessLoop(Module parent)
        throws TorqueException
    {
        if (parent.getModuleId() != ROOT_ID)
        {
            Module parentParent = parent.getParent();
            if (parentParent != null && parentParent == this)
            {
                return true;
            }
        }
        return false;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public AttributeGroup createNewGroup (IssueType issueType)
        throws TorqueException
    {
        return issueType.createNewGroup(this);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getDedupeGroupsWithAttributes(IssueType issueType)
        throws TorqueException
    {
        List result = null;
        if(issueType == null)
        {
            result = new Vector(0);
        }
        else
        {
            Object obj = getMethodResult().get(this,
                    GET_DEDUPE_GROUPS_WITH_ATTRIBUTES, issueType);
            if (obj == null)
            {
                List attributeGroups = issueType.getAttributeGroups(this, true);
                result = new ArrayList(attributeGroups.size());
                for (Iterator itr = attributeGroups.iterator(); itr.hasNext();)
                {
                    AttributeGroup ag = (AttributeGroup) itr.next();
                    if (ag.getDedupe() && !ag.getAttributes().isEmpty())
                    {
                        result.add(ag);
                    }
                }
                getMethodResult().put(result, this,
                        GET_DEDUPE_GROUPS_WITH_ATTRIBUTES, issueType);
            }
            else
            {
                result = (List) obj;
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getDedupeAttributeGroups(IssueType issueType)
        throws TorqueException
    {
        return getDedupeAttributeGroups(issueType, true);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getDedupeAttributeGroups(IssueType issueType,
                                         boolean activeOnly)
        throws TorqueException
    {
        List groups = issueType.getAttributeGroups(this, activeOnly);
        List dedupeGroups = new ArrayList();
        for (int i =0;i< groups.size(); i++)
        {
            AttributeGroup group = (AttributeGroup)groups.get(i);
            if (group.getDedupe())
            {
                dedupeGroups.add(group);
            }
        }
        return dedupeGroups;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public int getDedupeSequence(IssueType issueType)
        throws TorqueException
    {
        return issueType.getDedupeSequence(this);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public ScarabUser[] getEligibleIssueReporters()
        throws TorqueException
    {
        return getUsers(ScarabSecurity.ISSUE__ENTER);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public ScarabUser[] getEligibleUsers(Attribute attribute)
        throws TorqueException,ScarabException
    {
        ScarabUser[] users = null;
        if (attribute.isUserAttribute()) 
        {
            String permission = attribute.getPermission();
            if (permission == null) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionNoAttributePermission,
                        attribute.getName());
            }
            else 
            {
                users = getUsers(permission);
            }
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getSavedReports(final ScarabUser user)
        throws TorqueException,ScarabException
    {
        List reports = null;
        final Object obj = ScarabCache.get(this, GET_SAVED_REPORTS, user); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria()
                .add(ReportPeer.DELETED, 0);
            final Criteria.Criterion cc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.MODULE__PK, Criteria.EQUAL);
            cc.and(crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL));
            final Criteria.Criterion personalcc = crit.getNewCriterion(
                ReportPeer.SCOPE_ID, Scope.PERSONAL__PK, Criteria.EQUAL);
            personalcc.and(crit.getNewCriterion(
                ReportPeer.USER_ID, user.getUserId(), Criteria.EQUAL));
            final Criteria.Criterion personalmodulecc = crit.getNewCriterion(
                ReportPeer.MODULE_ID, getModuleId(), Criteria.EQUAL);
            personalmodulecc.or(crit.getNewCriterion(
                ReportPeer.MODULE_ID, null, Criteria.EQUAL));
            personalcc.and(personalmodulecc);
            cc.or(personalcc);
            crit.add(cc);
            crit.addAscendingOrderByColumn(ReportPeer.SCOPE_ID);
            final List torqueReports = ReportPeer.doSelect(crit);      
            // create ReportBridge's from torque Reports.
            if (!torqueReports.isEmpty()) 
            {
                reports = new ArrayList(torqueReports.size());
                for (Iterator i = torqueReports.iterator(); i.hasNext();) 
                {
                    final Report torqueReport = (Report)i.next();
                    try 
                    {
                        reports.add( new ReportBridge(torqueReport) );
                    }
                    catch (org.xml.sax.SAXException e)
                    {
                        getLog().warn("Could not parse the report id=" +
                                 torqueReport.getReportId() + 
                                 ", so it has been marked as deleted.");
                        torqueReport.setDeleted(true);
                        torqueReport.save();
                    }     
                    catch(Exception e)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,e);
                    }
                }
            }
            else 
            {
                reports = Collections.EMPTY_LIST;
            }

            ScarabCache.put(reports, this, GET_SAVED_REPORTS, user);
        }
        else 
        {
            reports = (List)obj;
        }
        return reports;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAttributes(final IssueType issueType)
        throws TorqueException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
        return getAttributes(crit);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAttributes(final Criteria criteria)
        throws TorqueException
    {
        final List moduleAttributes = getRModuleAttributes(criteria);
        final List attributes = new ArrayList(moduleAttributes.size());
        for (int i=0; i<moduleAttributes.size(); i++)
        {
            attributes.add(
               ((RModuleAttribute) moduleAttributes.get(i)).getAttribute());
        }
        return attributes;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUserAttributes(IssueType issueType)
        throws TorqueException
    {
        return getUserAttributes(issueType, true);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUserAttributes(IssueType issueType, boolean activeOnly)
        throws TorqueException
    {
        List rModuleAttributes = getRModuleAttributes(issueType, activeOnly, USER);
        List userAttributes = new ArrayList();

        for (int i=0; i<rModuleAttributes.size(); i++)
        {
            Attribute att = ((RModuleAttribute)rModuleAttributes.get(i)).getAttribute();
            userAttributes.add(att);
        }
        return userAttributes;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUserPermissions(IssueType issueType)
        throws TorqueException
    {
        List userAttrs = getUserAttributes(issueType, true);
        List permissions = new ArrayList();
        for (int i = 0; i < userAttrs.size(); i++)
        {
            String permission = ((Attribute)userAttrs.get(i)).getPermission();
            if (!permissions.contains(permission))
            {
                permissions.add(permission);
            }
        }
        return permissions;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public int getLastAttribute(IssueType issueType, String attributeType)
        throws TorqueException
    {
        List moduleAttributes = getRModuleAttributes(issueType, false, attributeType);
        int last = 0;

        for (int i=0; i<moduleAttributes.size(); i++)
        {
               int order = ((RModuleAttribute) moduleAttributes.get(i))
                         .getOrder();
               if (order > last)
               {
                   last = order;
               }
        }
        return last;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public int getLastAttributeOption(Attribute attribute, 
                                      IssueType issueType)
        throws TorqueException
    {
      List moduleOptions = getRModuleOptions(attribute, issueType);
      int last = 0;
      for (int i=0; i<moduleOptions.size(); i++)
        {
          int order = ((RModuleOption) moduleOptions.get(i))
            .getOrder();
          if (order > last)
            {
              last = order;
            }
        }
      return last;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void shiftAttributeOption(Attribute attribute, 
                                    IssueType issueType,
                                    int offset)
        throws TorqueException
    {
      List moduleOptions = getRModuleOptions(attribute, issueType, false);
      RModuleOption rmo;
      for (int i=0; i<moduleOptions.size(); i++)
        {
          rmo = (RModuleOption) moduleOptions.get(i);
          int order = rmo.getOrder();
          if (order >= offset && !rmo.getActive())
            {
              rmo.setOrder(order+1);
              rmo.save();
            }
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAvailableAttributes(IssueType issueType, 
                                       String attributeType)
        throws TorqueException
    {
        List allAttributes = AttributePeer.getAttributes(attributeType);
        List availAttributes = new ArrayList();
        List rModuleAttributes = getRModuleAttributes(issueType, false,
                                                      attributeType);
        List moduleAttributes = new ArrayList();
        if (rModuleAttributes.isEmpty())
        {
             availAttributes = allAttributes;
        }
        else
        {
            for (int i=0; i<rModuleAttributes.size(); i++)
            {
                moduleAttributes.add(
                   ((RModuleAttribute) rModuleAttributes.get(i)).getAttribute());
            }


            for (int i=0; i<allAttributes.size(); i++)
            {
                Attribute att = (Attribute)allAttributes.get(i);
                if (!moduleAttributes.contains(att))
                {
                    availAttributes.add(att);
                }
            }
         }
        return availAttributes;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAvailableAttributeOptions(Attribute attribute,
                                             IssueType issueType)
        throws TorqueException
    {
        List rModuleOptions = getRModuleOptions(attribute, issueType, false);
        List moduleOptions = new ArrayList();
        if (rModuleOptions != null)
        {
            for (int i=0; i<rModuleOptions.size(); i++)
            {
                moduleOptions.add(
                   ((RModuleOption) rModuleOptions.get(i)).getAttributeOption());
            }
        }

        List allOptions = attribute.getAttributeOptions(true);
        List availOptions = new ArrayList();

        for (int i=0; i<allOptions.size(); i++)
        {
            AttributeOption option = (AttributeOption)allOptions.get(i);
            if (!moduleOptions.contains(option) && !option.getDeleted())
            {
                availOptions.add(option);
            }
        }
        return availOptions;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getDefaultRModuleUserAttributes(IssueType issueType)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_DEFAULT_RMODULE_USERATTRIBUTES, 
                                     issueType); 
        if (obj == null) 
        {        
            result = new LinkedList();
            Attribute[] attributes = new Attribute[3];
            int count = 0;
            //attributes[count++] = issueType.getDefaultTextAttribute(this);
            //if (attributes[0] == null) 
            //{
            //    count = 0;
            //}            
            List rma1s = getRModuleAttributes(issueType, true, NON_USER);
            Iterator i = rma1s.iterator();

            // Find first default text attribute ...
            while (i.hasNext())
            {
                RModuleAttribute rmat = (RModuleAttribute)i.next();
                Attribute a = rmat.getAttribute();
                if (a.isTextAttribute() && rmat.getIsDefaultText()) 
                {
                    attributes[count++] = a;
                    break;
                }
            }

            // Add all UserAttributes
            List rma2s = getRModuleAttributes(issueType, true, USER);
            i = rma2s.iterator();
            while (i.hasNext() && count < 3)            
            {
                Attribute a = ((RModuleAttribute)i.next()).getAttribute();
                attributes[count++] = a;
            }

            // if we still have less than 3 attributes, give the non user
            // attributes another try
            i = rma1s.iterator();
            while (i.hasNext() && count < 3)            
            {
                Attribute a = ((RModuleAttribute)i.next()).getAttribute();
                if (!a.equals(attributes[0]) && !a.equals(attributes[1])) 
                {
                    attributes[count++] = a;
                }                
            }

            for (int j=0; j<attributes.length; j++) 
            {
                if (attributes[j] != null) 
                {
                    RModuleUserAttribute rmua = 
                        RModuleUserAttributeManager.getInstance();
                    rmua.setAttribute(attributes[j]);
                    rmua.setIssueType(issueType);
                    rmua.setOrder(j+1);
                    result.add(rmua);
                }
            }
            ScarabCache.put(result, this, GET_DEFAULT_RMODULE_USERATTRIBUTES, 
                            issueType);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public Issue getIssueById(String id)
        throws TorqueException
    {
        return IssueManager.getIssueById(id, getCode());
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getIssueTypes()
        throws TorqueException
    {
        return getIssueTypes(true); 
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getIssueTypes(boolean activeOnly)
        throws TorqueException
    {
        List types = null;
        Boolean activeOnlyValue = activeOnly ? Boolean.TRUE : Boolean.FALSE;
        Object obj = ScarabCache.get(this, GET_ISSUE_TYPES, activeOnlyValue);
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer. ISSUE_TYPE_ID);
            crit.add(RModuleIssueTypePeer.MODULE_ID, getModuleId());
            if (activeOnly)
            {
                crit.add(RModuleIssueTypePeer.ACTIVE, true);
            }
            crit.add(IssueTypePeer.PARENT_ID, 0);
            crit.add(IssueTypePeer.DELETED, 0);
            crit.addAscendingOrderByColumn(RModuleIssueTypePeer.PREFERRED_ORDER);             
            types = IssueTypePeer.doSelect(crit);
            ScarabCache.put(types, this, "getIssueTypes", activeOnlyValue);
        }
        else 
        {
            types = (List)obj;
        }
        return types;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getNavIssueTypes()
        throws TorqueException
    {
        List types = null;
        Object obj = getMethodResult().get(this, GET_NAV_ISSUE_TYPES); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer. ISSUE_TYPE_ID);
            crit.add(RModuleIssueTypePeer. MODULE_ID, getModuleId());
            crit.add(RModuleIssueTypePeer.ACTIVE, true);
            crit.add(RModuleIssueTypePeer.DISPLAY, true);
            crit.add(IssueTypePeer.PARENT_ID, 0);
            crit.add(IssueTypePeer.DELETED, 0);
            crit.addAscendingOrderByColumn(
                RModuleIssueTypePeer.PREFERRED_ORDER);
            types = IssueTypePeer.doSelect(crit);
            getMethodResult().put(types, this, GET_NAV_ISSUE_TYPES);
        }
        else 
        {
            types = (List)obj;
        }
        return types;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAvailableIssueTypes()
        throws TorqueException
    {
        List availIssueTypes = null;
        Object obj = ScarabCache.get(this, GET_AVAILABLE_ISSUE_TYPES); 
        if (obj == null) 
        {
            availIssueTypes = new ArrayList();
            List allIssueTypes = IssueTypePeer.getAllIssueTypes(false);
            List currentIssueTypes = getIssueTypes(false);
            Iterator iter = allIssueTypes.iterator();
            while (iter.hasNext())
            {
                IssueType issueType = (IssueType)iter.next();
                if (IssueTypePeer.getRootKey().equals(issueType.getParentId())
                    && !IssueTypePeer.getRootKey().equals(issueType.getIssueTypeId())
                    && !currentIssueTypes.contains(issueType))
                {
                    availIssueTypes.add(issueType);
                }
            }
            ScarabCache.put(availIssueTypes, this, GET_AVAILABLE_ISSUE_TYPES);
        }
        else 
        {
            availIssueTypes = (List)obj;
        }
        return availIssueTypes;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleAttributes(Criteria crit)
        throws TorqueException
    {
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.addJoin(RModuleAttributePeer.ATTRIBUTE_ID, 
                     AttributePeer.ATTRIBUTE_ID);
        crit.add(AttributePeer.DELETED, false);
        return RModuleAttributePeer.doSelect(crit);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleAttribute addRModuleAttribute(final IssueType issueType,
                                                final Attribute attribute)
        throws TorqueException, ScarabException
    {
        String attributeType = null;
        attributeType = (attribute.isUserAttribute() ? USER : NON_USER);

        final RModuleAttribute rma = new RModuleAttribute();
        rma.setModuleId(getModuleId());
        rma.setIssueTypeId(issueType.getIssueTypeId());
        rma.setAttributeId(attribute.getAttributeId());
        rma.setOrder(getLastAttribute(issueType, attributeType) + 1);
        rma.setConditionsArray(attribute.getConditionsArray(), attribute.getConditionOperator());
        rma.save();
        getRModuleAttributes(issueType, false, attributeType).add(rma);

        // Add to template type
        final IssueType templateType = IssueTypeManager
            .getInstance(issueType.getTemplateId(), false);
        final RModuleAttribute rma2 = new RModuleAttribute();
        rma2.setModuleId(getModuleId());
        rma2.setIssueTypeId(templateType.getIssueTypeId());
        rma2.setAttributeId(attribute.getAttributeId());
        rma2.setOrder(getLastAttribute(templateType, attributeType) + 1);
        rma2.save();
        return rma;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleOption addRModuleOption(IssueType issueType, 
                                          AttributeOption option)
        throws TorqueException
    {
        RModuleOption rmo = new RModuleOption();
        rmo.setModuleId(getModuleId());
        rmo.setIssueTypeId(issueType.getIssueTypeId());
        rmo.setOptionId(option.getOptionId());
        rmo.setDisplayValue(option.getName());
        rmo.setOrder(getLastAttributeOption(option.getAttribute(), issueType) + 1);
        return rmo;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleAttribute getRModuleAttribute(Attribute attribute,
			IssueType issueType) throws TorqueException {
		RModuleAttribute rma = null;
		if (attribute != null && issueType != null) {
			List rmas = null;
			if (attribute.isUserAttribute()) {
				rmas = getRModuleAttributes(issueType, false, USER);
			} else {
				rmas = getRModuleAttributes(issueType, false, NON_USER);
			}
			Iterator i = rmas.iterator();
			while (i.hasNext()) {
				rma = (RModuleAttribute) i.next();
				if (rma.getAttribute().equals(attribute)) {
					break;
				} else {
					rma = null;
				}
			}
		}
		return rma;
	}
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleAttributes(IssueType issueType)
        throws TorqueException
    {
        return getRModuleAttributes(issueType, false);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean hasAttributes(final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.addSelectColumn("count(" + RModuleAttributePeer.ATTRIBUTE_ID + ")");
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleAttributes(IssueType issueType, boolean activeOnly)
        throws TorqueException
    {
        return getRModuleAttributes(issueType, activeOnly, "all");
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleAttributes(IssueType issueType, boolean activeOnly,
                                     String attributeType)
        throws TorqueException
    {
        List rmas = null;
        Boolean activeBool = (activeOnly ? Boolean.TRUE : Boolean.FALSE);
        Object obj = getMethodResult().get(this, GET_R_MODULE_ATTRIBUTES,
            issueType,  activeBool, attributeType);
        if (obj == null)
        {
            Criteria crit = new Criteria();
            Integer issueTypeId = issueType.getIssueTypeId();
            Integer moduleId    = getModuleId();
            crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, issueTypeId);
            crit.add(RModuleAttributePeer.MODULE_ID, moduleId);
            crit.addAscendingOrderByColumn(RModuleAttributePeer.PREFERRED_ORDER);
            crit.addAscendingOrderByColumn(RModuleAttributePeer.DISPLAY_VALUE);
            
            if (activeOnly)
            {
                crit.add(RModuleAttributePeer.ACTIVE, true);
            }
            
            crit.addJoin(AttributePeer.ATTRIBUTE_ID, RModuleAttributePeer.ATTRIBUTE_ID); 
            if (USER.equals(attributeType))
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY);
            }
            else if (NON_USER.equals(attributeType))
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY,
                         Criteria.NOT_EQUAL);
            }
            
            rmas = RModuleAttributePeer.doSelect(crit); 
            getMethodResult().put(rmas, this, GET_R_MODULE_ATTRIBUTES, 
                issueType, activeBool, attributeType);
        }
        else
        {
            rmas = (List)obj;
        }
        return rmas;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAllAttributes()
        throws TorqueException
    {
    	Criteria crit = new Criteria();
    	crit.addJoin(RModuleAttributePeer.ATTRIBUTE_ID, AttributePeer.ATTRIBUTE_ID);
    	crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());  	 
    	crit.setDistinct();
    	List result = AttributePeer.doSelect(crit);
    	
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAllOptionAttributes()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.addJoin(RModuleAttributePeer.ATTRIBUTE_ID, AttributePeer.ATTRIBUTE_ID);
        crit.addIn(AttributePeer.ATTRIBUTE_TYPE_ID, OptionAttributeIds );
        crit.add(AttributePeer.DELETED, false);
        crit.add(RModuleAttributePeer.ACTIVE, true);
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.addAscendingOrderByColumn(
        		AttributePeer.ATTRIBUTE_NAME);
        crit.setDistinct();
        List result = AttributePeer.doSelect(crit);
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAllAttributeOptions(Integer attributeId)
            throws TorqueException, ScarabException
    {
        List result;
        if (attributeId == null)
        {
            this.getLog().warn(
                    "No attribute specified while fetching attribute options.");
            result = Collections.EMPTY_LIST;
        } else
        {
            int id = attributeId.intValue();
            Attribute attribute = Attribute.getInstance(id);
            if (attribute == null)
            {
                this.getLog().warn(
                        "No options found for Attribute [" + attributeId + "]");
                // L10NMessage msg = new
                // L10NMessage(L10NKeySet.AttributeNotInSession,""+attributeId);
                // throw new ScarabException(msg);
                result = Collections.EMPTY_LIST;
            } else
            {
                // Integer attributeId = attribute.getAttributeId();

                Criteria crit = new Criteria();
                crit.add(AttributeOptionPeer.ATTRIBUTE_ID, attributeId);
                crit.add(AttributeOptionPeer.DELETED, false);
                result = AttributeOptionPeer.doSelect(crit);
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getActiveAttributesByName(IssueType issueType,
                                          String attributeType)
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.MODULE_ID, getModuleId());
        crit.add(RModuleAttributePeer.ISSUE_TYPE_ID, 
                 issueType.getIssueTypeId());
        crit.addJoin(RModuleAttributePeer.ATTRIBUTE_ID, 
                     AttributePeer.ATTRIBUTE_ID);
        crit.add(AttributePeer.DELETED, false);
        crit.add(RModuleAttributePeer.ACTIVE, true);
        if (USER.equals(attributeType))
        {
            crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                     AttributeTypePeer.USER_TYPE_KEY);
            crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                     RModuleAttributePeer.ATTRIBUTE_ID); 
        }
        else if (NON_USER.equals(attributeType))
        {
            crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                     AttributeTypePeer.USER_TYPE_KEY,
                     Criteria.NOT_EQUAL);
        }
        crit.addAscendingOrderByColumn(
                RModuleAttributePeer.DISPLAY_VALUE);
        return AttributePeer.doSelect(crit);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleOptions(Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        return getRModuleOptions(attribute, issueType, true);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleOptions(Attribute attribute, IssueType issueType,
                                  boolean activeOnly)
        throws TorqueException
    {
        List allRModuleOptions    = getAllRModuleOptions(attribute, issueType);
        List resultRModuleOptions = null;

        if (allRModuleOptions != null) 
        {
            resultRModuleOptions = new ArrayList(allRModuleOptions.size());
            int orderIndex = 0;
            for (int i = 0; i < allRModuleOptions.size(); i++) 
            {
                RModuleOption rmo = (RModuleOption) allRModuleOptions.get(i);
                if (!activeOnly || rmo.getActive()) 
                {
                    rmo.setOrder(++orderIndex); // take care that the option order is consecutive
                    resultRModuleOptions.add(rmo);
                }
            }
        }

        return resultRModuleOptions;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
private List getAllRModuleOptions(Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        List rModOpts = EmptyList;

        if(attribute != null)
        {
            Object obj = getMethodResult().get(this, GET_ALL_R_MODULE_OPTIONS, attribute, issueType); 
            if (obj == null)
            {
                List options = attribute.getAttributeOptions(true);
                if (options != null && options.size() > 0)
                {
                    Integer[] optIds = new Integer[options.size()];
                    for (int i=optIds.length-1; i>=0; i--)
                    {
                        optIds[i] = ((AttributeOption)options.get(i)).getOptionId();
                    }
    
                    Criteria crit = new Criteria();
                    crit.add(RModuleOptionPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
                    crit.add(RModuleOptionPeer.MODULE_ID, getModuleId());
                    crit.addIn(RModuleOptionPeer.OPTION_ID, optIds);
                    crit.addAscendingOrderByColumn(RModuleOptionPeer.PREFERRED_ORDER);
                    crit.addAscendingOrderByColumn(RModuleOptionPeer.DISPLAY_VALUE);
                    rModOpts = getRModuleOptions(crit);
    
                    // It would be extremely suspicious to see a null value here.
                    assert (rModOpts != null); // for development 
                    if(rModOpts == null)       // for production
                    {
                        rModOpts = EmptyList;
                    }
                }
                getMethodResult().put(rModOpts, this, GET_ALL_R_MODULE_OPTIONS, attribute, issueType);
            }
            else 
            {
                rModOpts = (List)obj;
            }
        }
        return rModOpts;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleOption getRModuleOption(AttributeOption option, 
                                          IssueType issueType)
        throws TorqueException
    {
        RModuleOption rmo = null;
        List rmos = getRModuleOptions(option.getAttribute(),
                                      issueType, false);
        
        RModuleOption testRMO = null;
        for (Iterator i = rmos.iterator();i.hasNext();)
        {
            testRMO = (RModuleOption)i.next();
            if (testRMO.getAttributeOption().equals(option))
            {
                rmo = testRMO;
                break;
            }
        }
        return rmo;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getAttributeOptions (Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        List attributeOptions = null;
        try
        {
            List rModuleOptions = getOptionTree(attribute, issueType, false);
            attributeOptions = new ArrayList(rModuleOptions.size());
            for (int i=0; i<rModuleOptions.size(); i++)
            {
                attributeOptions.add(
                    ((RModuleOption)rModuleOptions.get(i)).getAttributeOption());
            }
        }
        catch (Exception e)
        {
        }
        return attributeOptions;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getLeafRModuleOptions(Attribute attribute, IssueType issuetype)
        throws TorqueException
    {
        try
        {
            return getLeafRModuleOptions(attribute, issuetype, true);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getLeafRModuleOptions(Attribute attribute,
                                      IssueType issueType,
                                      boolean activeOnly)
        throws TorqueException
    {
        List rModOpts = null;        
        Boolean activeBool = (activeOnly ? Boolean.TRUE : Boolean.FALSE);
        Object obj = getMethodResult().get(this, GET_LEAF_R_MODULE_OPTIONS, 
                                           attribute, issueType, activeBool); 
        if (obj == null) 
        {        
            rModOpts = getRModuleOptions(attribute, issueType, activeOnly);
            if (rModOpts != null)
            {
                
                // put options in a map for searching
                Map optionsMap = new HashMap((int)(rModOpts.size()*1.5));
                for (int i=rModOpts.size()-1; i>=0; i--)
                {
                    RModuleOption rmo = (RModuleOption)rModOpts.get(i);
                    optionsMap.put(rmo.getOptionId(), null);
                }
                
                // remove options with descendants in the list
                for (int i=rModOpts.size()-1; i>=0; i--)
                {
                    AttributeOption option =
                        ((RModuleOption)rModOpts.get(i)).getAttributeOption();
                    List descendants = option.getChildren();
                    if (descendants != null)
                    {
                        for (int j=descendants.size()-1; j>=0; j--)
                        {
                            AttributeOption descendant =
                                (AttributeOption)descendants.get(j);
                            if (optionsMap
                                 .containsKey(descendant.getOptionId()))
                            {
                                rModOpts.remove(i);
                                break;
                            }
                        }
                    }
                }
                getMethodResult().put(rModOpts, this, GET_LEAF_R_MODULE_OPTIONS, 
                                      attribute, issueType, activeBool); 
            }
        }
        else 
        {
            rModOpts = (List)obj;
        }
        
        return rModOpts;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getOptionTree(Attribute attribute, IssueType issueType)
        throws TorqueException
    {
        return getOptionTree(attribute, issueType, true);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getOptionTree(Attribute attribute, IssueType issueType,
                              boolean activeOnly)
        throws TorqueException
    {
        // I think this code should place an option that had multiple parents -
        // OSX and Mac,BSD is usual example - into the list in multiple places
        // and it should have the level set differently for the two locations.
        // The code is currently only placing the option in the list once.
        // Since the behavior is not well spec'ed, leaving as it is. - jdm

        List moduleOptions = null;
        moduleOptions = getRModuleOptions(attribute, issueType, activeOnly);
        if (moduleOptions == null)
        {
            return moduleOptions;
        }

        int size = moduleOptions.size();
        List[] ancestors = new List[size];

        // find all ancestors
        for (int i=size-1; i>=0; i--)
        {
            AttributeOption option =
                ((RModuleOption)moduleOptions.get(i)).getAttributeOption();
            ancestors[i] = option.getAncestors();
        }

        for (int i=0; i<size; i++)
        {
            RModuleOption moduleOption = (RModuleOption)moduleOptions.get(i);
            int level = 1;
            if (ancestors[i] != null)
            {
                // Set level for first ancestor as the option is only
                // shown once. 
                for (int j=ancestors[i].size()-1; j>=0; j--)
                {
                    AttributeOption ancestor =
                        (AttributeOption)ancestors[i].get(j);

                    for (int k=0; k<i; k++) 
                    {
                        RModuleOption potentialParent = (RModuleOption)
                            moduleOptions.get(k);
                        if (ancestor.getOptionId()
                            .equals(potentialParent.getOptionId()) &&
                            !ancestor.getOptionId()
                            .equals(moduleOption.getOptionId())   ) 
                        {
                            moduleOption.setLevel(level++);
                        }
                    }
                }
            }
        }

        return moduleOptions;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public String getOptionsTreeAsJSON(RunData data, String fromValue, Attribute attribute, Issue issue, boolean activeOnly) throws TorqueException 
    {    

        getLog().debug("Build options tree for Attribute [" + attribute.getName() + "]");
    	
    	List<RModuleOption> moduleOptions = (List<RModuleOption>) getRModuleOptions(attribute, issue.getIssueType(), activeOnly);
    		if (moduleOptions == null) {
    			return null;
    		}    	
    	    		
    		StringBuffer json = new StringBuffer("{ 'attributeId' : ");    		
    		json.append(attribute.getAttributeId());
    		json.append(", 'name' : '");
    		json.append(attribute.getName());
    		json.append("', '_children': [");
    		
			boolean first = true;
			
    		for (RModuleOption moduleOption : moduleOptions) {    			
        		if (!AbstractScarabModule.canMakeTransitionForOption(data, fromValue, moduleOption, issue, false)) continue;
    			if (moduleOption.getAttributeOption().getAncestors().size() == 1) {
    				if (!first) {
    					json.append(", ");
    				}
					json.append(this.getModuleOptionAsJSON(data, fromValue, attribute, issue, moduleOption));
    				first = false;
    			}
    		}
    		
    		json.append("]}");
    		
    		return json.toString();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
private String getModuleOptionAsJSON(RunData data, String fromValue, Attribute attribute, Issue issue, RModuleOption moduleOption) throws TorqueException {
    	StringBuffer json = new StringBuffer("{ 'optionId': ");
    	json.append(moduleOption.getOptionId());
    	json.append(", 'displayValue': '");
    	json.append(moduleOption.getDisplayValue());
    	json.append("', '_children': [");

		boolean first = true;

		moduleOption.getChildren(moduleOption.getIssueType());
		
    	for (RModuleOption rmo : (List<RModuleOption>) moduleOption.getChildren(moduleOption.getIssueType())) {
    		if (!AbstractScarabModule.canMakeTransitionForOption(data, fromValue, rmo, issue, false)) continue;
			if (!first) {
				json.append(", ");
			}
			json.append(this.getModuleOptionAsJSON(data, fromValue, attribute, issue, rmo));
			first = false;
    	}

    	json.append("]}");
    	
    	return json.toString();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getRModuleIssueTypes(String sortColumn, String sortPolarity)
        throws TorqueException
    {
        List types = null;
        Object obj = ScarabCache.get(this, GET_R_MODULE_ISSUE_TYPES); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.PARENT_ID, 0)
                .add(IssueTypePeer.DELETED, 0);
            if (sortColumn.equals("name"))
            {
                if (sortPolarity.equals("desc"))
                {
                    crit.addDescendingOrderByColumn(IssueTypePeer.NAME);
                }
                else
                {
                    crit.addAscendingOrderByColumn(IssueTypePeer.NAME);
                }
            }
            else
            {
                // sortColumn defaults to sequence #
                if (sortPolarity.equals("desc"))
                {
                    crit.addDescendingOrderByColumn(RModuleIssueTypePeer
                                                    .PREFERRED_ORDER);
                }
                else
                {
                    crit.addAscendingOrderByColumn(RModuleIssueTypePeer
                                                   .PREFERRED_ORDER);
                }
            }
            types = RModuleIssueTypePeer.doSelect(crit);
            ScarabCache.put(types, this, GET_R_MODULE_ISSUE_TYPES);
        }
        else 
        {
            types = (List) obj;
        }
        return types;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addAttributeOption(final IssueType issueType, 
            final AttributeOption option)
        throws TorqueException, ScarabException
    {
        final RModuleOption rmo = addRModuleOption(issueType, option);
        rmo.save();
        shiftAttributeOption(option.getAttribute(), issueType, rmo.getOrder());

        // add module-attributeoption mappings to template type
        final IssueType templateType = IssueTypeManager
                 .getInstance(issueType.getTemplateId());
        final RModuleOption rmo2 = addRModuleOption(templateType, option);
        rmo2.save();
        //FIXME: is it useful to shift options for the templateType?
        //shiftAttributeOption(option.getAttribute(), templateType, rmo.getOrder());
        
        //if the cache is not cleared, when two options are added at the same time, 
        //getLastAttributeOption does not take into account the newest active options.
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void setRmaBasedOnIssueType(final RIssueTypeAttribute ria)
        throws TorqueException, ScarabException
    {
        final RModuleAttribute rma = new RModuleAttribute(); 
        rma.setModuleId(getModuleId());
        rma.setIssueTypeId(ria.getIssueTypeId());
        rma.setAttributeId(ria.getAttributeId());
        rma.setActive(ria.getActive());
        rma.setRequired(ria.getRequired());
        rma.setOrder(ria.getOrder());
        rma.setQuickSearch(ria.getQuickSearch());
        rma.setDefaultTextFlag(ria.getDefaultTextFlag());
        rma.save();
        final RModuleAttribute rma2 = rma.copy();
        rma2.setModuleId(getModuleId());
        rma2.setIssueTypeId(ria.getIssueType().getTemplateId());
        rma2.setAttributeId(ria.getAttributeId());
        rma2.setActive(ria.getActive());
        rma2.setRequired(ria.getRequired());
        rma2.setOrder(ria.getOrder());
        rma2.setQuickSearch(ria.getQuickSearch());
        rma2.setDefaultTextFlag(ria.getDefaultTextFlag());
        rma2.save();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void setRmoBasedOnIssueType(final RIssueTypeOption rio)
        throws TorqueException, ScarabException
    {
        final RModuleOption rmo = new RModuleOption(); 
        rmo.setModuleId(getModuleId());
        rmo.setIssueTypeId(rio.getIssueTypeId());
        rmo.setOptionId(rio.getOptionId());
        rmo.setActive(rio.getActive());
        rmo.setOrder(rio.getOrder());
        rmo.setWeight(rio.getWeight());
        rmo.save();
        final RModuleOption rmo2 = rmo.copy();
        rmo2.setModuleId(getModuleId());
        rmo2.setIssueTypeId(rio.getIssueType().getTemplateId());
        rmo2.setOptionId(rio.getOptionId());
        rmo2.setActive(rio.getActive());
        rmo2.setOrder(rio.getOrder());
        rmo2.setWeight(rio.getWeight());
        rmo2.save();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean includesIssueType(final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleIssueTypePeer.MODULE_ID,
                 getModuleId());
        crit.add(RModuleIssueTypePeer.ISSUE_TYPE_ID,
                 issueType.getIssueTypeId());
        return RModuleIssueTypePeer.count(crit) > 0;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public RModuleIssueType getRModuleIssueType(final IssueType issueType)
        throws TorqueException
    {
        RModuleIssueType rmit = null;
        try
        {
            final SimpleKey[] keys = { SimpleKey.keyFor(getModuleId()), 
                                 SimpleKey.keyFor(issueType.getIssueTypeId())
            };
            rmit = RModuleIssueTypeManager.getInstance(new ComboKey(keys));
        }
        catch (NoRowsException e)
        {
            // ignore and return null, if the rmit does not exist
        }
        return rmit;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getTemplateTypes()
        throws TorqueException, ScarabException
    {
        List templateTypes = new ArrayList();
        final Object obj = ScarabCache.get(this, GET_TEMPLATE_TYPES); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                     IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.DELETED, 0);
            final List rmits = RModuleIssueTypePeer.doSelect(crit);
            for (int i=0; i<rmits.size(); i++)
            {
                final RModuleIssueType rmit = (RModuleIssueType)rmits.get(i);
                final IssueType templateType = rmit.getIssueType().getTemplateIssueType();
                templateTypes.add(templateType);
            }
            ScarabCache.put(templateTypes, this, GET_TEMPLATE_TYPES);
        }
        else 
        {
            templateTypes = (List)obj;
        }
        return templateTypes;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUnapprovedQueries() throws TorqueException
    {
        List queries = null;
        Object obj = ScarabCache.get(this, GET_UNAPPROVED_QUERIES); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(3);
            crit.add(QueryPeer.APPROVED, 0)
                .add(QueryPeer.DELETED, 0)
                .add(QueryPeer.MODULE_ID, getModuleId());
            queries = QueryPeer.doSelect(crit);
            ScarabCache.put(queries, this, GET_UNAPPROVED_QUERIES);
        }
        else 
        {
            queries = (List)obj;
        }
        return queries;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public List getUnapprovedTemplates() throws TorqueException
    {
        List templates = null;
        Object obj = ScarabCache.get(this, GET_UNAPPROVED_TEMPLATES); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(3);
            crit.add(IssueTemplateInfoPeer.APPROVED, 0)
                .addJoin(IssuePeer.ISSUE_ID, IssueTemplateInfoPeer.ISSUE_ID)
                .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MOVED, 0)
                .add(IssuePeer.MODULE_ID, getModuleId());
            templates = IssuePeer.doSelect(crit);
            ScarabCache.put(templates, this, GET_UNAPPROVED_TEMPLATES);
        }
        else 
        {
            templates = (List)obj;
        }
        return templates;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void setInitialAttributesAndIssueTypes()
        throws TorqueException, DataSetException, ScarabException
    {
        isInitializing = true;
        ValidationException ve = null;
        try
        {
        // Add defaults for issue types and attributes 
        // from parent module
        final Module parentModule = ModuleManager.getInstance(getParentId());
        if(parentModule != null && parentModule.getModuleId().intValue() != 0){
        	inheritFromParent(parentModule);  //don't inherit anything from global data/module
        }
        
        final List defaultIssueTypes = IssueTypePeer.getDefaultIssueTypes();
        for (int i=0; i< defaultIssueTypes.size(); i++)
        {
            final IssueType defaultIssueType = (IssueType)defaultIssueTypes.get(i);
            if (!includesIssueType(defaultIssueType))
            {
                try
                {
                    addIssueType(defaultIssueType);
                }
                catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
            }
        }
        }
        finally
        {
            isInitializing = false;
        }
        if (ve != null) 
        {
            throw ve;
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
protected void inheritFromParent(final Module parentModule)
        throws TorqueException, ScarabException
    {
        final Integer newModuleId = getModuleId();
        AttributeGroup ag1;
        AttributeGroup ag2;
        RModuleAttribute rma1 = null;
        RModuleAttribute rma2 = null;
            
        //save RModuleAttributes for template types.
        final List templateTypes = parentModule.getTemplateTypes();
        for (int i=0; i<templateTypes.size(); i++)
        {
            final IssueType it = (IssueType)templateTypes.get(i);
            final List rmas = parentModule.getRModuleAttributes(it);
            for (int j=0; j<rmas.size(); j++)
            {
                rma1 = (RModuleAttribute)rmas.get(j);
                rma2 = rma1.copy();
                rma2.setModuleId(newModuleId);
                rma2.setAttributeId(rma1.getAttributeId());
                rma2.setIssueTypeId(rma1.getIssueTypeId());
                getLog().debug("[ASM] Saving rma for new template type: " + 
                                    rma2.getModuleId()
                                    + "-" + rma2.getIssueTypeId() + "-" +
                                    rma2.getAttributeId());
                rma2.save();
            }
        }

        // set module-issue type mappings
        final List rmits = parentModule.getRModuleIssueTypes();
        for (int i=0; i<rmits.size(); i++)
        {
            final RModuleIssueType rmit1 = (RModuleIssueType)rmits.get(i);
            final RModuleIssueType rmit2 = rmit1.copy();
            rmit2.setModuleId(newModuleId);
            rmit2.save();
            final IssueType issueType = rmit1.getIssueType();

            // set attribute group defaults
            final List attributeGroups = issueType
                .getAttributeGroups(parentModule, true);
            for (int j=0; j<attributeGroups.size(); j++)
            {
                ag1 = (AttributeGroup)attributeGroups.get(j);
                ag2 = ag1.copy();
                ag2.setModuleId(newModuleId);
                ag2.getRAttributeAttributeGroups().clear();    // are saved later
                ag2.save();

                final List attributes = ag1.getAttributes();
                for (int k=0; k<attributes.size(); k++)
                {
                    final Attribute attribute = (Attribute)attributes.get(k);

                    // set attribute-attribute group defaults
                    final RAttributeAttributeGroup raag1 = ag1
                        .getRAttributeAttributeGroup(attribute);
                    final RAttributeAttributeGroup raag2 = raag1.copy();
                    raag2.setGroupId(ag2.getAttributeGroupId());
                    raag2.setAttributeId(raag1.getAttributeId());
                    raag2.setOrder(raag1.getOrder());
                    raag2.save();
                }
            }

            // set module-attribute defaults
            final List rmas = parentModule.getRModuleAttributes(issueType);
            if (rmas != null && rmas.size() >0)
            {
                for (int j=0; j<rmas.size(); j++)
                {
                    rma1 = (RModuleAttribute)rmas.get(j);
                    rma2 = rma1.copy();
                    rma2.setModuleId(newModuleId);
                    rma2.setAttributeId(rma1.getAttributeId());
                    rma2.setIssueTypeId(rma1.getIssueTypeId());
                    rma2.save();

                    // set module-option mappings
                    final Attribute attribute = rma1.getAttribute();
                    if (attribute.isOptionAttribute())
                    {
                        final List rmos = parentModule.getRModuleOptions(attribute,
                                                                   issueType);
                        if (rmos != null && rmos.size() > 0)
                        {
                            for (int m=0; m<rmos.size(); m++)
                            {
                                final RModuleOption rmo1 = (RModuleOption)rmos.get(m);
                                final RModuleOption rmo2 = rmo1.copy();
                                rmo2.setOptionId(rmo1.getOptionId());
                                rmo2.setModuleId(newModuleId);
                                rmo2.setIssueTypeId(issueType.getIssueTypeId());
                                rmo2.save();

                                // Save module-option mappings for template types
                                final RModuleOption rmo3 = rmo1.copy();
                                rmo3.setOptionId(rmo1.getOptionId());
                                rmo3.setModuleId(newModuleId);
                                rmo3.setIssueTypeId(issueType.getTemplateId());
                                rmo3.save();
                            }
                        }
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public boolean isInitializing()
        throws TorqueException
    {
        return isInitializing;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public String getIssueRegexString()
        throws TorqueException
    {
        // regex =  /(issue|bug)\s+#?\d+/i
        List rmitsList = getRModuleIssueTypes();
        StringBuffer regex = new StringBuffer(30 + 10 * rmitsList.size());
        regex.append(REGEX_PREFIX);
        Iterator rmits = rmitsList.iterator();
        while (rmits.hasNext()) 
        {
            regex.append('|')
                .append(((RModuleIssueType)rmits.next()).getDisplayName());
        }
        regex.append(REGEX_SUFFIX);
        return regex.toString();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public REProgram getIssueRegex()
        throws TorqueException
    {
        String regex = getIssueRegexString();
        RECompiler rec = new RECompiler();
        REProgram rep = null;
        try
        {
            rep = rec.compile(regex);
        }
        catch (RESyntaxException e)
        {
            getLog().error("Could not compile regex: " + regex, e);
            try
            {
                rep = rec.compile(REGEX_PREFIX + REGEX_SUFFIX);
            }
            catch (RESyntaxException ee)
            {
                // this should not happen, but it might when we localize
                getLog().error("Could not compile standard regex", ee);
                try
                {
                    rep = rec.compile("[:alpha:]+\\d+");
                }
                catch (RESyntaxException eee)
                {
                    // this will never happen, but log it, just in case 
                    getLog().error("Could not compile simple id regex", eee);
                }
            }
        }
        // FIXME: we should cache the above result
        return rep;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public static Attribute getInstance(int id)
        throws TorqueException
    {
        return getInstance(new Integer(id));
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public static Attribute getInstance(Integer id)
        throws TorqueException
    {
        return AttributeManager.getInstance(id);
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public static Attribute getInstance(final String attributeName)
        throws TorqueException
    {
        Attribute result = null;
// TODO Should attributes even be cached by name?   What if the name is changed?
        Object obj = ScarabCache.get(ATTRIBUTE, GET_INSTANCE, attributeName.toLowerCase()); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add (AttributePeer.ATTRIBUTE_NAME, attributeName);
            crit.setIgnoreCase(true);
            final List attributes = AttributePeer.doSelect(crit);
            if (attributes.size() > 0)
            {
                result = (Attribute) attributes.get(0);
                ScarabCache.put(result, ATTRIBUTE, GET_INSTANCE, attributeName.toLowerCase());
            } 
        }
        else 
        {
            result = (Attribute)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public static boolean checkForDuplicate(String attributeName)
        throws TorqueException
    {
        return (getInstance(attributeName) != null);
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public static boolean checkForDuplicate(String attributeName,
                                            Attribute attribute)
        throws TorqueException
    {
        return (checkForDuplicate(attributeName) &&
                !attributeName.equals(attribute.getName()));
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public String getCreatedUserName() throws TorqueException
    {
        final Integer userId = getCreatedBy();
        String userName = null;
        if (userId == null || userId.intValue() == 0)
        {
            userName = DEFAULT.getMessage();
        }
        else
        {
            final ScarabUser su = ScarabUserManager
                .getInstance(SimpleKey.keyFor(userId));
            userName = su.getName();
        }
        return userName;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public static List getAllAttributeTypes()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(ATTRIBUTE, GET_ALL_ATTRIBUTE_TYPES); 
        if (obj == null) 
        {        
            result = AttributeTypePeer.doSelect(new Criteria());
            ScarabCache.put(result, ATTRIBUTE, GET_ALL_ATTRIBUTE_TYPES);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public List getCompatibleAttributeTypes()
        throws TorqueException, DataSetException
    {
        List result = null;
        final Object obj = ScarabCache.get(this, GET_COMPATIBLE_ATTRIBUTE_TYPES); 
        if (obj == null) 
        {
            boolean inUse = !isNew();
            if (inUse) 
            {
                // check to see if attribute really has been used
                final Criteria crit = new Criteria();
                crit.add(AttributeValuePeer.ATTRIBUTE_ID, getAttributeId());
                inUse = AttributeValuePeer.count(crit) > 0; 
            }
            if (inUse) 
            {
                if (isTextAttribute()) 
                {
                    final Criteria crit = new Criteria();
                    crit.addIn(AttributeTypePeer.ATTRIBUTE_TYPE_ID, AttributeTypePeer.TEXT_PKS);
                    result = AttributeTypePeer.doSelect(crit);                
                }
                else if (this.isOptionAttribute())
                {
                    final Criteria crit = new Criteria();
                    crit.addIn(AttributeTypePeer.ATTRIBUTE_TYPE_ID, AttributeTypePeer.OPTION_PKS);
                    result = AttributeTypePeer.doSelect(crit);                
                }
                else 
                {
                    result = Collections.EMPTY_LIST;
                }
            }
            else 
            {
                result = getAllAttributeTypes();
            }
            ScarabCache.put(result, this, GET_COMPATIBLE_ATTRIBUTE_TYPES);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public AttributeType getAttributeType()
        throws TorqueException
    {
        AttributeType result = null;
        Object obj = ScarabCache.get(this, GET_ATTRIBUTE_TYPE);
        if (obj == null) 
        {
            result = super.getAttributeType();
            ScarabCache.put(result, this, GET_ATTRIBUTE_TYPE);
        }
        else
        {
            result = (AttributeType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public static List getAllAttributes()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(ATTRIBUTE, GET_ALL_ATTRIBUTES); 
        if (obj == null) 
        {        
            result = AttributePeer.doSelect(new Criteria());
            ScarabCache.put(result, ATTRIBUTE, GET_ALL_ATTRIBUTES);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean isOptionAttribute()
        throws TorqueException
    {
        if (getTypeId() != null) 
        {
            return getAttributeType().getAttributeClass().getName()
                .equals(SELECT_ONE);
        }
        return false;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean isUserAttribute()
        throws TorqueException
    {
        if (getTypeId() != null) 
        {
            return getAttributeType().getAttributeClass().getName()
                .equals(USER_ATTRIBUTE);
        }
        return false;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean isTextAttribute()
        throws TorqueException
    {
        boolean isText = false;
        if (getTypeId() != null) 
        {
            for (int i=0; i<TEXT_TYPES.length && !isText; i++) 
            {
                isText = TEXT_TYPES[i].equals(getAttributeType().getName());
            }
        }
        return isText;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean isIntegerAttribute()
        throws TorqueException
    {
        return getTypeId() != null 
                && INTEGER_ATTRIBUTE.equals(getAttributeType().getName());
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean isDateAttribute()
        throws TorqueException
    {
        boolean isDate = false;
        if(getTypeId() != null)
        {
            isDate = "date".equals(getAttributeType().getName());            
        }
        return isDate;
     }
            
// in java/org/tigris/scarab/om/Attribute.java
public AttributeOption getAttributeOption(Integer pk)
        throws TorqueException
    {
        if (optionsMap == null)
        {
            buildOptionsMap();
        }
        return (AttributeOption)optionsMap.get(pk);
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public AttributeOption getAttributeOption(String optionID)
        throws TorqueException
    {
        if (optionID == null || optionID.length() == 0)
        {
            throw new TorqueException("optionId is empty"); //EXCEPTION
        }
        return getAttributeOption(new Integer(optionID));
    }
            
// in java/org/tigris/scarab/om/Attribute.java
private List getAllAttributeOptions()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_ALL_ATTRIBUTE_OPTIONS); 
        if (obj == null) 
        {
            Criteria crit = new Criteria();
            crit.addJoin(AttributeOptionPeer.OPTION_ID, 
                         ROptionOptionPeer.OPTION2_ID);
            crit.add(AttributeOptionPeer.ATTRIBUTE_ID, this.getAttributeId());
            crit.addAscendingOrderByColumn(ROptionOptionPeer.PREFERRED_ORDER);
            result = AttributeOptionPeer.doSelect(crit);
            ScarabCache.put(result, this, GET_ALL_ATTRIBUTE_OPTIONS);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public List getParentChildAttributeOptions()
        throws TorqueException
    {
        if (parentChildAttributeOptions == null)
        {
            List rooList = getOrderedROptionOptionList();
            List aoList = getOrderedAttributeOptionList();
            parentChildAttributeOptions = new ArrayList(rooList.size());
            for (int i=0; i<rooList.size();i++)
            {
                ROptionOption roo = (ROptionOption)rooList.get(i);
                AttributeOption ao = (AttributeOption)aoList.get(i);
    
                ParentChildAttributeOption pcao = ParentChildAttributeOption
                        .getInstance(roo.getOption1Id(), roo.getOption2Id());
                pcao.setParentId(roo.getOption1Id());
                pcao.setOptionId(roo.getOption2Id());
                pcao.setPreferredOrder(roo.getPreferredOrder());
                pcao.setWeight(roo.getWeight());
                pcao.setName(ao.getName());
                pcao.setDeleted(ao.getDeleted());
                pcao.setAttributeId(this.getAttributeId());
                pcao.setStyle(ao.getStyle());
                parentChildAttributeOptions.add(pcao);
            }
        }
        return parentChildAttributeOptions;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public List getOrderedROptionOptionList()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_ORDERED_ROPTIONOPTION_LIST); 
        if (obj == null) 
        {        
            if (orderedROptionOptionList == null)
            {
                Criteria crit = new Criteria();
                crit.addJoin(AttributeOptionPeer.OPTION_ID, 
                             ROptionOptionPeer.OPTION2_ID);
                crit.add(AttributeOptionPeer.ATTRIBUTE_ID, getAttributeId());
                crit.addAscendingOrderByColumn(
                    ROptionOptionPeer.PREFERRED_ORDER);
                orderedROptionOptionList = ROptionOptionPeer.doSelect(crit);
            }
            result = orderedROptionOptionList;
            ScarabCache.put(result, this, GET_ORDERED_ROPTIONOPTION_LIST);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public List getOrderedAttributeOptionList()
        throws TorqueException
    {
        if (orderedAttributeOptionList == null)
        {
            Criteria crit = new Criteria();
            crit.addJoin(AttributeOptionPeer.OPTION_ID, ROptionOptionPeer.OPTION2_ID);
            crit.add(AttributeOptionPeer.ATTRIBUTE_ID, this.getAttributeId());
            crit.addAscendingOrderByColumn(ROptionOptionPeer.PREFERRED_ORDER);
            orderedAttributeOptionList = AttributeOptionPeer.doSelect(crit);
        }
        return orderedAttributeOptionList;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public List getAttributeOptions(boolean includeDeleted)
        throws TorqueException
    {
        List allOptions = getAllAttributeOptions();
        List nonDeleted = new ArrayList(allOptions.size());
        if (includeDeleted) 
        {
            return allOptions;
        }
        else 
        {
            for (int i=0; i<allOptions.size(); i++) 
            {
                AttributeOption option = (AttributeOption)allOptions.get(i);
                if (!option.getDeleted())
                {
                    nonDeleted.add(option);
                }
            }
            return nonDeleted;
        }
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public synchronized void buildOptionsMap()
        throws TorqueException
    {
        if (getAttributeType().getAttributeClass().getName()
             .equals(SELECT_ONE))
        {
            // synchronized method due to getattributeOptionsWithDeleted, this needs
            // further investigation !FIXME!
            attributeOptionsWithDeleted = this.getAllAttributeOptions();
            optionsMap = new HashMap((int)(1.25*attributeOptionsWithDeleted.size()+1));
    
            attributeOptionsWithoutDeleted = new ArrayList(attributeOptionsWithDeleted.size());
            for (int i=0; i<attributeOptionsWithDeleted.size(); i++) 
            {
                AttributeOption option = (AttributeOption)attributeOptionsWithDeleted.get(i);
                optionsMap.put(option.getOptionId(), option);
                if (!option.getDeleted()) 
                {
                    attributeOptionsWithoutDeleted.add(attributeOptionsWithDeleted.get(i));
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public List getActivitys() throws TorqueException
    {
        return null;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public Attribute copyAttribute(ScarabUser user)
        throws TorqueException
    {
        Attribute newAttribute = new Attribute();
        newAttribute.setName(getName() + " (copy)");
        newAttribute.setDescription(getDescription());
        newAttribute.setStyle(getStyle());
        newAttribute.setFieldSize(getFieldSize());
        newAttribute.setFormat(getFormat());
        newAttribute.setHint(getHint());
        newAttribute.setTypeId(getTypeId());
        newAttribute.setPermission(getPermission());
        newAttribute.setRequiredOptionId(getRequiredOptionId());
        newAttribute.setConditionsArray(getConditionsArray(), getConditionOperator());
        newAttribute.setAction(getAction());
        newAttribute.setCreatedBy(user.getUserId());
        newAttribute.setCreatedDate(new Date());
        newAttribute.setDeleted(getDeleted());
        newAttribute.setMultiValue(getMultiValue());
        newAttribute.save();

        List attributeOptions = getAttributeOptions();
        for (int i=0;i<attributeOptions.size();i++)
        {
            AttributeOption option = (AttributeOption)attributeOptions.get(i);
            AttributeOption newOption = new AttributeOption();
            newOption.setOptionId(option.getOptionId());
            newOption.setAttributeId(newAttribute.getAttributeId());
            newOption.setName(option.getName());
            newOption.setDeleted(option.getDeleted());
            newOption.save();

            // Copy options's record in  R_OPTION_OPTION table
            List roos = option.getROptionOptionsRelatedByOption2Id();
            for (int j=0;j<roos.size();j++)
            {
                ROptionOption roo = (ROptionOption)roos.get(j);
                ROptionOption newRoo = new ROptionOption();
                newRoo.setOption2Id(newOption.getOptionId());
                newRoo.setOption1Id(roo.getOption1Id());
                newRoo.setRelationshipId(roo.getRelationshipId());
                newRoo.setWeight(roo.getWeight());
                newRoo.setPreferredOrder(roo.getPreferredOrder());
                newRoo.save();
             }
        }
        return newAttribute;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasModuleMappings()
        throws TorqueException, DataSetException
    {
        return hasMapping((Module) null, (IssueType) null);
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasMapping(final Module module, final IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        if (module != null)
        {
            crit.add(RModuleAttributePeer.MODULE_ID,
                     module.getModuleId());
        }
        if (issueType != null)
        {
            crit.add(RModuleAttributePeer.ISSUE_TYPE_ID,
                     issueType.getIssueTypeId());
        }
        crit.addSelectColumn("count(" + RModuleAttributePeer.ATTRIBUTE_ID + ")");
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasGlobalIssueTypeMappings()
        throws TorqueException, DataSetException
    {
        return hasGlobalMapping((IssueType) null);
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean hasGlobalMapping(IssueType issueType)
        throws TorqueException, DataSetException
    {
        final Criteria crit = new Criteria();
        crit.add(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        if (issueType != null)
        {
            crit.add(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
                     issueType.getIssueTypeId());
        }
        crit.addSelectColumn("count(" + RIssueTypeAttributePeer.ATTRIBUTE_ID
                             + ')');
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt() > 0;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public void deleteModuleMappings()
        throws TorqueException, ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID,
                 getAttributeId());
        crit.addJoin(RAttributeAttributeGroupPeer.GROUP_ID,
                     AttributeGroupPeer.ATTRIBUTE_GROUP_ID);
        crit.add(AttributeGroupPeer.MODULE_ID, (Object)null, Criteria.NOT_EQUAL);
        final List raags = RAttributeAttributeGroupPeer.doSelect(crit);
        for (Iterator i = raags.iterator(); i.hasNext();)
        {
            ((RAttributeAttributeGroup)i.next()).delete();
        }

        crit = new Criteria();
        crit.add(RModuleAttributePeer.ATTRIBUTE_ID, 
                 getAttributeId());
        final List rmas = RModuleAttributePeer.doSelect(crit);
        for (int i=0; i<rmas.size(); i++)
        {
            final RModuleAttribute rma = (RModuleAttribute)rmas.get(i);
            rma.delete(true);
        }
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public void deleteIssueTypeMappings()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID,
                 getAttributeId());
        crit.addJoin(RAttributeAttributeGroupPeer.GROUP_ID,
                     AttributeGroupPeer.ATTRIBUTE_GROUP_ID);
        crit.add(AttributeGroupPeer.MODULE_ID, null);
        List raags = RAttributeAttributeGroupPeer.doSelect(crit);
        for (Iterator i = raags.iterator(); i.hasNext();)
        {
            ((RAttributeAttributeGroup)i.next()).delete();
        }

        crit = new Criteria();
        crit.add(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        List rias = RIssueTypeAttributePeer.doSelect(crit);
        for (Iterator i = rias.iterator(); i.hasNext();)
        {
            ((RIssueTypeAttribute)i.next()).delete();
        }
        
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/Attribute.java
private List getAssociatedIssueTypes()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                 getAttributeId());
        crit.addJoin(RIssueTypeAttributePeer.ISSUE_TYPE_ID,
                 IssueTypePeer.ISSUE_TYPE_ID);
        List issueTypeList = IssueTypePeer.doSelect(crit);
        return issueTypeList;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean isSystemDefined()
        throws TorqueException
    {
        boolean systemDefined = false;
        List issueTypeList = getAssociatedIssueTypes();
        for (Iterator i = issueTypeList.iterator(); i.hasNext();)
        {
            if (((IssueType)i.next()).isSystemDefined())
            {
                systemDefined = true;
                break;
            }
        }
        return systemDefined;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public List<Condition> getConditions() throws TorqueException
    {
        if (collConditions == null)
        {
            Criteria crit = new Criteria();
            crit.add(ConditionPeer.ATTRIBUTE_ID, this.getAttributeId());
            crit.add(ConditionPeer.MODULE_ID, null);
            crit.add(ConditionPeer.TRANSITION_ID, null);
            crit.add(ConditionPeer.ISSUE_TYPE_ID, null);
            collConditions = getConditions(crit);
        }
        return collConditions;
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public void setConditionsArray(Integer aOptionId[], Integer operator) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.ATTRIBUTE_ID, this.getAttributeId());
        crit.add(ConditionPeer.OPERATOR, this.getConditionOperator());
        crit.add(ConditionPeer.MODULE_ID, null);
        crit.add(ConditionPeer.ISSUE_TYPE_ID, null);
        crit.add(ConditionPeer.TRANSITION_ID, null);
        ConditionPeer.doDelete(crit);
        this.save();
        this.getConditions().clear();
        ConditionManager.clear();
        if (aOptionId != null)
            for (int i=0; i<aOptionId.length; i++)
	        {
	            if (aOptionId[i].intValue() != 0)
	            {
		            Condition cond = new Condition();
		            cond.setAttributeId(this.getAttributeId());
		            cond.setOptionId(aOptionId[i]);
		            cond.setModuleId(null);
		            cond.setIssueTypeId(null);
		            cond.setTransitionId(null);
		            cond.setUserId(null);
		            cond.setOperator(operator);
		            this.addCondition(cond);
		            cond.save();
	            }
	        }
    }
            
// in java/org/tigris/scarab/om/Attribute.java
public boolean isRequiredIf(Integer optionID) throws TorqueException
    {
        Condition cond = new Condition();
        cond.setAttributeId(this.getAttributeId());
        cond.setOptionId(optionID);
        cond.setModuleId(null);
        cond.setIssueTypeId(null);
        cond.setTransitionId(null);
        return this.getConditions().contains(cond);
    }
            
// in java/org/tigris/scarab/om/ReportManager.java
public List getNotDeletedModuleReports(Module module) 
        throws TorqueException
    {
        Criteria crit=new Criteria()
           .add(ReportPeer.DELETED,false)
           .add(ReportPeer.MODULE_ID,module.getModuleId())
           .add(ReportPeer.SCOPE_ID,Scope.MODULE__PK);

        List reports=ReportPeer.doSelect(crit);
        
        return reports;
    }
            
// in java/org/tigris/scarab/om/ReportManager.java
protected Persistent putInstanceImpl(Persistent om)
    throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(ReportPeer.REPORT_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/ActivitySetTypeManager.java
public static ActivitySetType getInstance(final String activitySetTypeName) 
        throws TorqueException,ScarabException
    {
        ActivitySetType ttype = null; 
        Object obj = ScarabCache.get(TRANSACTION_TYPE, GET_INSTANCE, 
                                     activitySetTypeName);
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(ActivitySetTypePeer.NAME, activitySetTypeName);
            final List activitySetTypes = ActivitySetTypePeer.doSelect(crit);
            if (activitySetTypes.size() < 1) 
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetTypenameNotFound, 
                        activitySetTypeName);
            }
            if (activitySetTypes.size() > 1)
            {
                throw new ScarabException(
                        L10NKeySet.ExceptionActivitySetDuplicateTypename,
                        activitySetTypeName);
            }
            ttype = (ActivitySetType)activitySetTypes.get(0);
            ScarabCache.put(ttype, "ActivitySetType", "getInstance", 
                            activitySetTypeName);
        }
        else 
        {
            ttype = (ActivitySetType)obj;
        }
        
        return ttype;
    }
            
// in java/org/tigris/scarab/om/RModuleOptionManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(RModuleOptionPeer.MODULE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/RModuleOptionManager.java
public static final RModuleOption getInstance(Integer moduleId,  
        Integer issueTypeId, Integer optionId)
        throws TorqueException
    {
        SimpleKey[] keys = {
            new NumberKey(moduleId.toString()), 
            new NumberKey(issueTypeId.toString()), 
            new NumberKey(optionId.toString())
        };
        return getInstance(new ComboKey(keys));
    }
            
// in java/org/tigris/scarab/om/RModuleOptionManager.java
public static final RModuleOption getInstance(Module module, 
        IssueType issueType, AttributeOption option)
        throws TorqueException
    {
        SimpleKey[] keys = {
            SimpleKey.keyFor(module.getModuleId()),
            SimpleKey.keyFor(issueType.getIssueTypeId()),
            SimpleKey.keyFor(option.getOptionId())
        };
        return getInstance(new ComboKey(keys));
    }
            
// in java/org/tigris/scarab/om/TransitionPeer.java
public static void doDelete(Transition tran) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.TRANSITION_ID, tran.getTransitionId());
        ConditionPeer.doDelete(crit);
        BaseTransitionPeer.doDelete(tran);
    }
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
static public List<NotificationRule> getCustomization(Object moduleId, Object userId, Object activityType) throws TorqueException
        {
            List<NotificationRule> entries = null;
            Criteria crit = new Criteria();
            crit.add(MODULE_ID,       moduleId,     Criteria.EQUAL);
            crit.add(USER_ID,         userId,       Criteria.EQUAL);
            crit.add(ACTIVITY_TYPE,   activityType, Criteria.EQUAL);
            try {
                entries = (List<NotificationRule>)doSelect(crit);
            } catch (TorqueException e) {
                log.error("getPendingNotifications(): " + e);
            }
            /*
            if(entries.size()==0)
            {
                NotificationRule rule = 
                    NotificationRule.createDefaultRule(
                            (Integer)moduleId,
                            (Integer)userId,
                            NotificationManagerFactory.getInstance().getManagerId(),
                            ActivityType.getActivityType((String)activityType));
            }
            */
            return entries;
        }
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
static public Map<String,List<NotificationRule>> getCustomization(Object moduleId, Object userId) throws TorqueException
        {
            Map<String,List<NotificationRule>> entries = new Hashtable<String,List<NotificationRule>>();
            Set<String> codes = (Set<String>)ActivityType.getActivityTypeCodes();
            Iterator<String> iter = codes.iterator();
            while(iter.hasNext())
            {
                String code = (String)iter.next();
                List<NotificationRule> items = getCustomization(moduleId, userId, code);
                entries.put(code,items);
            }
            return entries;
        }
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
static public List<NotificationRule> getNotificationRules(ScarabUser user, Module module) throws TorqueException
        {
            List<NotificationRule> entries = new ArrayList<NotificationRule>();
            Set<String> codes = (Set<String>)ActivityType.getActivityTypeCodes();
            Iterator<String> iter = codes.iterator();
            Integer moduleId = module.getModuleId();
            Integer userId   = user.getUserId();
            while(iter.hasNext())
            {
                String code = (String)iter.next();
                List<NotificationRule> items = getCustomization(moduleId, userId, code);
                if(items != null && items.size()>0)
                entries.add(items.get(0));
            }
            return entries;
        }
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
public static void saveConditions(ScarabUser user, Module module, Integer[] aOptionId, Integer operator) throws TorqueException
        {
            deleteConditions(user, module);
            ConditionManager.clear();
            if (aOptionId != null)
                for (int i=0; i<aOptionId.length; i++)
                {
                    if (aOptionId[i].intValue() != 0)
                    {
                        Condition cond = new Condition();
                        cond.setAttributeId(null);
                        cond.setOptionId(aOptionId[i]);
                        cond.setModuleId(module.getModuleId());
                        cond.setIssueTypeId(null);
                        cond.setTransitionId(null);
                        cond.setUserId(user.getUserId());
                        cond.setOperator(operator);
                        cond.save();
                    }
                }
        }
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
public static List<Condition> getConditions(ScarabUser user, Module module) throws TorqueException
        {
            List<Condition> result = null;
            Criteria crit = new Criteria();
            crit.add(ConditionPeer.USER_ID, user.getUserId());
            crit.add(ConditionPeer.MODULE_ID, module.getModuleId());
            result = (List<Condition>)ConditionPeer.doSelect(crit);
            return result;
        }
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
public static Notification getEmptyNotificationFor(ScarabUser user, Module module) throws TorqueException
        {
            Notification notification = null;
            return notification;
            
        }
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
public static void deleteConditions(ScarabUser user, Module module) throws TorqueException
        {
            Criteria crit = new Criteria();
            crit.add(ConditionPeer.ATTRIBUTE_ID, null);
            crit.add(ConditionPeer.MODULE_ID, module.getModuleId());
            crit.add(ConditionPeer.ISSUE_TYPE_ID, null);
            crit.add(ConditionPeer.TRANSITION_ID, null);
            crit.add(ConditionPeer.USER_ID, user.getUserId());
            ConditionPeer.doDelete(crit);
        }
            
// in java/org/tigris/scarab/om/Issue.java
public static Issue getNewInstance(Module module, 
                                       IssueType issueType)
        throws TorqueException
    {
        Issue issue = new Issue(module, issueType);
        return issue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public String getUniqueId()
        throws TorqueException
    {
        if (getIdPrefix() == null)
        {
            setIdPrefix(getModule().getCode());
        }
        return getIdPrefix() + getIdCount();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public String getFederatedId()
        throws TorqueException
    {
        if (getIdDomain() != null) 
        {
            return getIdDomain() + '-' + getUniqueId();
        }
        return getUniqueId();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public static List parseIssueList(final Module module, final String theList)
        throws TorqueException, DataSetException
    {
        final String[] issues = StringUtils.split(theList, ",");
        final List results = new ArrayList();
        for (int i = 0; i < issues.length; i++)
        {
            if (issues[i].indexOf('*') != -1)
            {
                // Probably better to use more Torque here, but this
                // is definitely going to be faster and more
                // efficient.
                final String sql = "SELECT CONCAT(" + IssuePeer.ID_PREFIX + ',' +
                    IssuePeer.ID_COUNT + ") FROM " + IssuePeer.TABLE_NAME +
                    " WHERE " + IssuePeer.ID_PREFIX + " = '" +
                    module.getCode() + '\'';
                final List records = BasePeer.executeQuery(sql);
                for (Iterator j = records.iterator(); j.hasNext();)
                {
                    final Record rec = (Record)j.next();
                    results.add(rec.getValue(1).asString());
                }
            }
            // check for a -
            else if (issues[i].indexOf('-') == -1)
            {
                // Make sure user is not trying to access issues from another
                // module.
                final FederatedId fid = createFederatedId(module, issues[i]);
                if (!fid.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    final String[] args = { fid.getPrefix(), module.getCode() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixNotForModule", args)); //EXCEPTION
                }
                results.add(issues[i]);
            }
            else
            {
                final String[] issue = StringUtils.split(issues[i], "-");
                if (issue.length != 2)
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDRangeNotValid", issues[i])); //EXCEPTION
                }
                FederatedId fidStart = createFederatedId(module, issue[0]);
                FederatedId fidStop = createFederatedId(module, issue[1]);
                if (!fidStart.getPrefix().equalsIgnoreCase(module.getCode()) ||
                    !fidStop.getPrefix().equalsIgnoreCase(module.getCode()))
                {
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesNotForModule",
                                         module.getCode())); //EXCEPTION
                }
                else if (!fidStart.getPrefix()
                         .equalsIgnoreCase(fidStop.getPrefix()))
                {
                    final String[] args = { fidStart.getPrefix(),
                                      fidStop.getPrefix() };
                    throw new TorqueException(Localization.format
                                        (ScarabConstants.DEFAULT_BUNDLE_NAME,
                                         module.getLocale(),
                                         "IssueIDPrefixesDoNotMatch", args)); //EXCEPTION
                }
                else if (fidStart.getCount() > fidStop.getCount())
                {
                    FederatedId swap = fidStart;
                    fidStart = fidStop;
                    fidStop = swap;
                }

                for (int j = fidStart.getCount(); j <= fidStop.getCount();j++)
                {
                    results.add(fidStart.getPrefix() + j);
                }
            }
        }
        return results;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private static FederatedId createFederatedId(Module module, String id)
        throws TorqueException
    {
        FederatedId fid = null;
        try
        {
            fid = new FederatedId(id.trim());
            if (fid.getPrefix() == null || fid.getPrefix().length() == 0)
            {
                fid.setPrefix(module.getCode());
            }
        }
        catch (Exception e)
        {
            throw new TorqueException("Invalid federated id: " + id); //EXCEPTION
        }
        return fid;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addUrl(final Attachment attachment, final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return addUrl(null, attachment, user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addUrl(ActivitySet activitySet, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        attachment.setTextFields(user, this, Attachment.URL__PK);
        attachment.save();

        activitySet = attachActivitySet(activitySet, user);

        // Save activity record
        ActivityManager
            .createTextActivity(this, activitySet, ActivityType.URL_ADDED, attachment);
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private Locale getLocale()
        throws TorqueException
    {
        return getModule().getLocale();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(final Attachment attachment, final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return addComment(null, attachment, user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet addComment(ActivitySet activitySet, 
                                  Attachment attachment, ScarabUser user)
        throws TorqueException, ScarabException
    {
        String comment = attachment.getData();
        if (comment == null || comment.length() == 0)
        {
            throw new ScarabException(L10NKeySet.NoDataInComment);
        }

        activitySet = attachActivitySet(activitySet, user);

        // populates the attachment with data to be a comment
        attachment = AttachmentManager
                        .getComment(attachment, this, user);

        ActivityManager
            .createTextActivity(this, activitySet,
                                ActivityType.COMMENT_ADDED, attachment);

        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.COMMENT_ADDED, activitySet, this, user);            

        index();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public synchronized void addFile(Attachment attachment, 
                                     ScarabUser user)
        throws TorqueException
    {
        attachment.setTypeId(Attachment.FILE__PK);
        attachment.setCreatedBy(user.getUserId());
        if (unSavedAttachments == null)
        {
            unSavedAttachments = new ArrayList();
        }
        unSavedAttachments.add(attachment);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public synchronized List getAttachments()
        throws TorqueException
    {
        if (unSavedAttachments != null && 
            unSavedAttachments.size() > 0)
        {
            return unSavedAttachments;
        }
        else
        {
            return super.getAttachments();
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public synchronized ActivitySet doSaveFileAttachments(final ScarabUser user)
        throws TorqueException, ScarabException
    {
        return doSaveFileAttachments(null, user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public synchronized ActivitySet doSaveFileAttachments(ActivitySet activitySet,
                                                          final ScarabUser user)
        throws TorqueException, ScarabException
    {
        if (unSavedAttachments == null)
        {
            return activitySet;
        }
        activitySet = attachActivitySet(activitySet, user);

        final Iterator itr = unSavedAttachments.iterator();
        while (itr.hasNext())
        {
            final Attachment attachment = (Attachment)itr.next();
            // make sure we set the issue to the newly created issue
            attachment.setIssue(this);
            attachment.save();

            // Save activity record
            ActivityManager
                .createTextActivity(this, activitySet, ActivityType.ATTACHMENT_CREATED, attachment);

           
        }
        // reset the super method so that the query has to hit the database again
        // so that all of the information is cleaned up and reset.
        super.collAttachments = null;
        // we don't need this one anymore either.
        this.unSavedAttachments = null;
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void removeFile(String index)
        throws TorqueException
    {
        int indexInt = Integer.parseInt(index) - 1;
        if (indexInt >= 0)
        {
            if (unSavedAttachments != null && unSavedAttachments.size() > 0)
            {
                unSavedAttachments.remove(indexInt);
            }
            else
            {
                List attachList = getAttachments();
                if (attachList != null && attachList.size() > 0)
                {
                    attachList.remove(indexInt);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public RModuleIssueType getRModuleIssueType()
        throws TorqueException
    {
        RModuleIssueType rmit = null;
        Module module = getModule();
        IssueType issueType = getIssueType();
        if (module != null && issueType != null) 
        {
            rmit = module.getRModuleIssueType(issueType);
        }
        return rmit;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public LinkedMap getModuleAttributeValuesMap()
        throws TorqueException
    {
        return getModuleAttributeValuesMap(true);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public LinkedMap getModuleAttributeValuesMap(final boolean isActive)
        throws TorqueException
    {
    	LinkedMap result = null;
        Object obj = getCachedObject(GET_MODULE_ATTRVALUES_MAP, isActive ? Boolean.TRUE : Boolean.FALSE);
        if (obj == null) 
        {        
            List attributes = null;
            Module module = getModule();
            IssueType issueType = getIssueType();
            if (isActive)
            {
                attributes = issueType.getActiveAttributes(module);
            }
            else
            {
                attributes = module.getAttributes(issueType);
            }
            Map siaValuesMap = getAttributeValuesMap();
            result = new LinkedMap((int)(1.25*attributes.size() + 1));
            for (int i=0; i<attributes.size(); i++)
            {
                String key = ((Attribute)attributes.get(i)).getName().toUpperCase();
                if (siaValuesMap.containsKey(key))
                {
                    result.put(key, siaValuesMap.get(key));
                }
                else 
                {
                    Attribute attr      = (Attribute)attributes.get(i);
                    AttributeValue aval = AttributeValue.getNewInstance(attr, this);
                    addAttributeValue(aval);
                    result.put(key, aval);
                }
            }
            putCachedObject(result, GET_MODULE_ATTRVALUES_MAP, isActive ? Boolean.TRUE : Boolean.FALSE);
        }
        else
        {
            result = (LinkedMap)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public LinkedMap getModuleOptionAttributeValuesMap()
    throws TorqueException
    {
        LinkedMap result = null;
        //Object obj = getCachedObject(GET_MODULE_OPTION_ATTRVALUES_MAP);
        Object obj = ScarabCache.get(this, GET_MODULE_OPTION_ATTRVALUES_MAP); 
        if (obj == null) 
        {        
            List attributes = null;
            Module module = getModule();
            IssueType issueType = getIssueType();
            attributes = issueType.getActiveAttributes(module);
            Map siaValuesMap = getAttributeValuesMap();
            result = new LinkedMap((int)(1.25*attributes.size() + 1));
            for (int i=0; i<attributes.size(); i++)
            {
                String key = ((Attribute)attributes.get(i)).getName().toUpperCase();
                AttributeValue aval;
                if (siaValuesMap.containsKey(key))
                {
                    aval = (AttributeValue)siaValuesMap.get(key);
                }
                else 
                {
                    Attribute attr = (Attribute)attributes.get(i);
                    aval           = AttributeValue.getNewInstance(attr, this);
                    addAttributeValue(aval);
                }
                if(aval.getOptionId() != null)
                {
                    result.put(key, aval);
                }
            }
            //putCachedObject(result, GET_MODULE_OPTION_ATTRVALUES_MAP);
            ScarabCache.put(result, this, GET_MODULE_OPTION_ATTRVALUES_MAP);
        }
        else
        {
            result = (LinkedMap)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void addAttributeValue(AttributeValue aval)
       throws TorqueException
    {
        List avals = getAttributeValues();
        if (!avals.contains(aval)) 
        {
            super.addAttributeValue(aval);
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getAttributeValue(String attributeName)
        throws TorqueException
    {
        Attribute attribute = Attribute.getInstance(attributeName);
        AttributeValue result;
        if(attribute == null)
        {
            result = null;
        }
        else
        {
            result = getAttributeValue(attribute);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getAttributeValue(int id)
        throws TorqueException
    {
        Attribute attribute = Attribute.getInstance(id);
        return getAttributeValue(attribute);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getAttributeValue(Attribute attribute)
       throws TorqueException
    {
        AttributeValue result = null;
        Object obj = ScarabCache.get(this, GET_ATTRVALUE, attribute); 
        if (obj == null) 
        {        
            if (isNew()) 
            {
                List avals = getAttributeValues();
                if (avals != null) 
                {
                    Iterator i = avals.iterator();
                    while (i.hasNext()) 
                    {
                        AttributeValue tempAval = (AttributeValue)i.next();
                        if (tempAval.getAttribute().equals(attribute)) 
                        {
                            result = tempAval;
                            break;
                        }
                    }
                }
            }
            else 
            {            
                Criteria crit = new Criteria(2)
                    .add(AttributeValuePeer.ISSUE_ID, getIssueId())        
                    .add(AttributeValuePeer.DELETED, false)        
                    .add(AttributeValuePeer.ATTRIBUTE_ID, 
                         attribute.getAttributeId());
                
                List avals = getAttributeValues(crit);
                if (avals.size() > 0)
                {
                    result = (AttributeValue)avals.get(0);
                }
                if (avals.size() > 1)
                {
                    getLog().error("getAttributeValue(): Error when retrieving attribute values of attribute. Expected 1 and found " + avals.size() + ". List follows: " + avals);
                }
            }
            ScarabCache.put(result, this, GET_ATTRVALUE, attribute);
        }
        else 
        {
            result = (AttributeValue)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getAttributeValues(Integer id)
       throws TorqueException
    {
        Attribute attribute = Attribute.getInstance(id);
        return getAttributeValues(attribute);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getAttributeValues(final Attribute attribute)
       throws TorqueException
    {
        List aval = (List)IssueManager.getMethodResult().get(this, GET_ATTRVALUES, attribute); 
        if (aval == null) 
        {        
            if (isNew()) 
            {
                final List avals = getAttributeValues();
                aval = new ArrayList();
                if (avals != null) 
                {
                    final Iterator i = avals.iterator();
                    while (i.hasNext()) 
                    {
                        final AttributeValue tempAval = (AttributeValue)i.next();
                        if (tempAval.getAttribute().equals(attribute)) 
                        {
                            aval.add(tempAval);
                        }
                    }
                }
            }
            else 
            {            
                final Criteria crit = new Criteria(2)
                    .add(AttributeValuePeer.DELETED, false)        
                    .add(AttributeValuePeer.ATTRIBUTE_ID, 
                         attribute.getAttributeId());
                
                aval = getAttributeValues(crit);
                IssueManager.getMethodResult().put(aval, this, GET_ATTRVALUES, attribute);
            }
        }
        return aval;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isAttributeValue(AttributeValue attVal)
       throws TorqueException
    {
        boolean isValue = false;
        List attValues = getAttributeValues(attVal.getAttribute());
        if (attValues.contains(attVal))
        {
            isValue = true;
        }
        return isValue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private AttributeValue getAttributeValueWithValue(Attribute att, String strVal, Integer numVal)
    	throws TorqueException
    {
        AttributeValue val = null;
        boolean bFound = false;
        List attValues = getAttributeValues(att);
        for (Iterator it = attValues.iterator(); !bFound && it.hasNext(); )
        {
			val = (AttributeValue)it.next();
			if (strVal != null)
			    bFound = val.getValue().equals(strVal);
			else if (!bFound && numVal != null)
			    bFound = val.getNumericValue().equals(numVal);
        }
        return val;        
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Map getAttributeValuesMap() throws TorqueException
    {
        Map result = null;
        Object obj = getCachedObject(GET_ATTRIBUTE_VALUES_MAP); 
        if (obj == null) 
        {
            final Criteria crit = new Criteria(2)
                .add(AttributeValuePeer.DELETED, false);        
            final List siaValues = getAttributeValues(crit);
            result = new HashMap((int)(1.25*siaValues.size() + 1));
            for (Iterator i = siaValues.iterator(); i.hasNext(); )
            {
                final AttributeValue att = (AttributeValue) i.next();
                result.put(att.getAttribute().getName().toUpperCase(), att);
            }

            putCachedObject(result, GET_ATTRIBUTE_VALUES_MAP);
        }
        else
        {
            result = (Map)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Map getAllAttributeValuesMap() 
        throws TorqueException
    {
        Map moduleAtts = getModuleAttributeValuesMap();
        Map issueAtts = getAttributeValuesMap();
        Map allValuesMap = new HashMap((int)(1.25*(moduleAtts.size() + 
                                            issueAtts.size())+1));

        allValuesMap.putAll(moduleAtts);
        allValuesMap.putAll(issueAtts);
        return allValuesMap;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean containsMinimumAttributeValues()
        throws TorqueException
    {
        List attributes = getIssueType()
            .getRequiredAttributes(getModule());

        boolean result = true;
        LinkedMap avMap = getModuleAttributeValuesMap();
        MapIterator i = avMap.mapIterator();
        while (i.hasNext()) 
        {
            AttributeValue aval = (AttributeValue)avMap.get(i.next());
            
            if (aval.getOptionId() == null && aval.getValue() == null) 
            {
                for (int j=attributes.size()-1; j>=0; j--) 
                {
                    if (aval.getAttribute().getPrimaryKey().equals(
                         ((Attribute)attributes.get(j)).getPrimaryKey())) 
                    {
                        result = false;
                        break;
                    }                    
                }
                if (!result) 
                {
                    break;
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getEligibleUsers(Attribute attribute)
        throws TorqueException, ScarabException
    {
        ScarabUser[] users = getModule().getEligibleUsers(attribute);
        // remove those already assigned
        List assigneeAVs = getAttributeValues(attribute);
        if (users != null && assigneeAVs != null) 
        {        
            for (int i=users.length-1; i>=0; i--) 
            {
                for (int j=assigneeAVs.size()-1; j>=0; j--) 
                {
                    AttributeValue av = (AttributeValue)assigneeAVs.get(j);
                    Integer avUserId = av.getUserId();
                    Integer userUserId = users[i].getUserId();
                    if ( av != null && avUserId != null && 
                         userUserId != null && 
                         avUserId.equals(userUserId))
                    {
                        users[i] = null;
                        break;
                    }
                }
            }
        }

        List eligibleUsers = new ArrayList(users.length);
        for (int i=0; i<users.length; i++) 
        {
            if (users[i] != null)
            {
                eligibleUsers.add(users[i]);
            }
        }

        return eligibleUsers;
    }
            
// in java/org/tigris/scarab/om/Issue.java
protected Set<ScarabUser> getUsersToEmail(String action, Issue issue, Set<ScarabUser> users)
        throws TorqueException
    {
        if (users == null)
        {
            users = new HashSet<ScarabUser>(1);
        }

        Module module = getModule();

        ScarabUser createdBy = issue.getCreatedBy();
        if (createdBy != null && !users.contains(createdBy) &&
            AttributePeer.EMAIL_TO.equals(action) &&
               createdBy.hasPermission(ScarabSecurity.ISSUE__ENTER, module))
        {
            users.add(createdBy);
        }

        Criteria crit = new Criteria()
            .add(AttributeValuePeer.ISSUE_ID, issue.getIssueId())
            .addJoin(AttributeValuePeer.ATTRIBUTE_ID,
                     AttributePeer.ATTRIBUTE_ID)
            .add(AttributePeer.ACTION, action)
            .add(RModuleAttributePeer.MODULE_ID, getModuleId())
            .add(RModuleAttributePeer.ISSUE_TYPE_ID, getTypeId())
            .add(AttributeValuePeer.DELETED, 0)
            .add(RModuleAttributePeer.ACTIVE, true)
            .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                     AttributeValuePeer.ATTRIBUTE_ID);
        List userAttVals = AttributeValuePeer.doSelect(crit);
        for (Iterator i = userAttVals.iterator(); i.hasNext(); )
        {
            AttributeValue attVal = (AttributeValue) i.next();
            try
            {
                ScarabUser su = ScarabUserManager
                    .getInstance(attVal.getUserId());
                if (!users.contains(su)
                    && su.hasPermission(attVal.getAttribute().getPermission(),
                                        module))
                {
                    users.add(su);
                }
            }
            catch (Exception e)
            {
                throw new TorqueException("Error retrieving users to email"); //EXCEPTION
            }
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Set<ScarabUser> getAllUsersToEmail(String action) throws TorqueException
    {
        Set<ScarabUser> result = null;
        Object obj = ScarabCache.get(this, GET_ALL_USERS_TO_EMAIL, action); 
        if (obj == null) 
        {        
            Set<ScarabUser> users = new HashSet<ScarabUser>();
            try
            {
                users = getUsersToEmail(action, this, users);
                List children = getChildren();
                for (int i=0;i<children.size();i++)
                {
                    Issue depIssue = IssueManager.getInstance
                        (((Depend) children.get(i)).getObserverId());
                    users = getUsersToEmail(action, depIssue, users);
                }
                result = users;
            }
            catch (Exception e)
            {
                getLog().error("Issue.getUsersToEmail(): ", e);
                throw new TorqueException("Error in retrieving users."); //EXCEPTION
            }
            ScarabCache.put(result, this, GET_ALL_USERS_TO_EMAIL, action);
        }
        else 
        {
            result = (Set)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getUserAttributeValue(final ScarabUser user, 
            final Attribute attribute)
        throws TorqueException
    {
        AttributeValue result = null;
        Object obj = getCachedObject(GET_USER_ATTRIBUTEVALUE,
            attribute.getAttributeId(), user.getUserId()); 
        if (obj == null) 
        {
            final Criteria crit = new Criteria()
                .add(AttributeValuePeer.ATTRIBUTE_ID, attribute.getAttributeId())
                .add(AttributeValuePeer.ISSUE_ID, getIssueId())
                .add(AttributeValuePeer.USER_ID, user.getUserId())
                .add(AttributeValuePeer.DELETED, 0);
            final List resultList = AttributeValuePeer.doSelect(crit);
            if (resultList != null && resultList.size() == 1)
            {
                result = (AttributeValue)resultList.get(0);
            }
            putCachedObject(result, GET_USER_ATTRIBUTEVALUE, 
                attribute.getAttributeId(), user.getUserId());
        }
        else 
        {
            result = (AttributeValue)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getUserAttributeValues() throws TorqueException
    {
        return getUserAttributeValues(null);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ScarabUser getFirstAssignedTo() throws TorqueException
    {
        String assignedToAttributeName = Environment.getConfigurationProperty("scarab.common.assignedTo", "assignedTo");
        List<AttributeValue> allAssignedUsers = getUserAttributeValues();
        Iterator<AttributeValue> iter = allAssignedUsers.iterator();
        ScarabUser result = null;
        while(iter.hasNext())
        {
            AttributeValue attval = iter.next();
            String attributeName = attval.getAttribute().getName();
            if(attributeName.equals(assignedToAttributeName))
            {
                result = attval.getScarabUser();
                break;
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getUserAttributeValues(final ScarabUser user) throws TorqueException
    {
        List result = null;
        Object obj = null;
        obj = getCachedUserAttributeValues(user);
        
        if (obj == null)
        {
            List attributeList = getModule().getUserAttributes(getIssueType(), true);
            List attributeIdList = new ArrayList();
            
            for (int i=0; i<attributeList.size(); i++) 
            {
                Attribute att = (Attribute) attributeList.get(i);
                attributeIdList.add(att.getAttributeId());
            }
            
            if(!attributeIdList.isEmpty())
            {
                Criteria crit = new Criteria()
                    .addIn(AttributeValuePeer.ATTRIBUTE_ID, attributeIdList)
                    .add(AttributeValuePeer.ISSUE_ID, getIssueId())
                    .add(AttributeValuePeer.DELETED, 0);
                if(user != null)
                {
                    crit.add(AttributeValuePeer.USER_ID, user.getUserId());
                }
                result = AttributeValuePeer.doSelect(crit);
            }
            else 
            {
                result = new ArrayList(0);
            }
            
            putCachedUserAttributeValues(user, result);
        }
        else
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getInitialActivitySet()
        throws TorqueException
    {
        ActivitySet activitySet = getActivitySetRelatedByCreatedTransId();
        if (activitySet == null) 
        {
            Log.get().warn("Creation ActivitySet is null for " + this);
        }
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Date getCreatedDate()
        throws TorqueException
    {
        ActivitySet creationSet = getActivitySetRelatedByCreatedTransId();
        Date result = null;
        if (creationSet == null) 
        {
            getLog().warn("Issue " + getUniqueId() + " (pk=" + getIssueId() +
                           ") does not have a creation ActivitySet");
        }
        else 
        {
            result = creationSet.getCreatedDate();
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ScarabUser getCreatedBy()
        throws TorqueException
    {
        ActivitySet creationSet = getActivitySetRelatedByCreatedTransId();
        ScarabUser result = null;
        if (creationSet == null) 
        {
            getLog().warn("Issue " + getUniqueId() + " (pk=" + getIssueId() +
                           ") does not have a creation ActivitySet");
        }
        else 
        {
            result = creationSet.getScarabUser();
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isCreatingUser(ScarabUser user)
         throws TorqueException
    {
        ActivitySet creationSet = getActivitySetRelatedByCreatedTransId();
        boolean result = false;
        if (creationSet == null) 
        {
            getLog().warn("Issue " + getUniqueId() + " (pk=" + getIssueId() +
                           ") does not have a creation ActivitySet");
        }
        else 
        {
            result = creationSet.getCreatedBy().equals(user.getUserId());
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getLastActivitySet()
        throws TorqueException
    {
        ActivitySet t = null;
        if (!isNew()) 
        {
            Object obj = ScarabCache.get(this, GET_LAST_TRANSACTION, this.getLastTransId());
            if (obj == null) 
            {        
                Criteria crit = new Criteria();
                crit.addJoin(ActivitySetPeer.TRANSACTION_ID, 
                         ActivityPeer.TRANSACTION_ID);
                crit.add(ActivityPeer.ISSUE_ID, getIssueId());
                Integer[] typeIds = {ActivitySetTypePeer.EDIT_ISSUE__PK, 
                                       ActivitySetTypePeer.MOVE_ISSUE__PK};
                crit.addIn(ActivitySetPeer.TYPE_ID, typeIds);
                // there could be multiple attributes modified during the 
                // creation which will lead to duplicates
                crit.setDistinct();
                crit.addDescendingOrderByColumn(ActivitySetPeer.CREATED_DATE);
                List activitySets = ActivitySetPeer.doSelect(crit);
                if (activitySets.size() > 0) 
                {
                    t = (ActivitySet)activitySets.get(0);
                }
                ScarabCache.put(t, this, GET_LAST_TRANSACTION, this.getLastTransId());
            }
            else 
            {
                t = (ActivitySet)obj;
            }
        }
        return t;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Date getModifiedDate()
        throws TorqueException
    {
        Date result = null;
        if (!isNew()) 
        {
            ActivitySet t = getLastActivitySet();
            if (t == null)
            {
                result = getCreatedDate();
            }
            else 
            {
                result = t.getCreatedDate();
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public long getHoursIdle() throws TorqueException, ParseException
    {
        Date now = new Date();
        Date date = null;
        Date onHoldUntil = null;
        long diffHours = 0;

        if (!isNew()) 
        {
            boolean onHold = isOnHold();
            if(onHold)
            {
                onHoldUntil = getOnHoldUntil(); // on Hold until this date
                if(onHoldUntil == null)
                {
                    return 0; // we are on hold but there is no end date, so we wait forever.
                }
                diffHours = (now.getTime() - onHoldUntil.getTime()) / (1000*60*60);
                if(diffHours < 0)
                {
                    return 0; // onHoldDate not yet reached, so we are not idle by definition
                }
            }
            ActivitySet t = getLastActivitySet();
            if (t == null)
            {
                date = getCreatedDate();
            }
            else 
            {
                date = t.getCreatedDate();
            }
            
            if(onHold)
            {
                if (date.before(onHoldUntil))
                {
                    // The date of last activity was before the onHoldUntil date
                    // In that case we count the end of the onHold period as the
                    // event.
                    date = onHoldUntil;
                }
            }
            
        }
        // Return the difference in hours between now and the last date of activities:
        diffHours = (now.getTime() - date.getTime()) / (1000*60*60);
        return diffHours;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ScarabUser getModifiedBy()
        throws TorqueException
    {
        ScarabUser result = null;
        if (!isNew()) 
        {
            ActivitySet t = getLastActivitySet();
            if (t == null)
            {
                result = getCreatedBy();
            }
            else 
            {
                result = ScarabUserManager
                    .getInstance(t.getCreatedBy());
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public int getCommentsCount() throws TorqueException
    {
        return getComments(true).size();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isCommentsLong() throws TorqueException
    {
        return (getCommentsCount() > getCommentsLimit());
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getComments(boolean full) throws TorqueException
    {
        List result = null;
        Boolean fullBool = (full ? Boolean.TRUE : Boolean.FALSE);
        Object obj = getCachedObject(GET_COMMENTS, fullBool);
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(AttachmentPeer.ISSUE_ID, getIssueId())
                .addJoin(AttachmentTypePeer.ATTACHMENT_TYPE_ID,
                         AttachmentPeer.ATTACHMENT_TYPE_ID)
                .add(AttachmentTypePeer.ATTACHMENT_TYPE_ID, 
                     Attachment.COMMENT__PK)
                .addDescendingOrderByColumn(AttachmentPeer.CREATED_DATE);
            if (!full)
            {
                crit.setLimit(getCommentsLimit());
            }
            result = AttachmentPeer.doSelect(crit);
            putCachedObject(result, GET_COMMENTS, fullBool);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getUrls() throws TorqueException
    {
        List result = null;
        Object obj = getCachedObject(GET_URLS);
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(AttachmentPeer.ISSUE_ID, getIssueId())
                .addJoin(AttachmentTypePeer.ATTACHMENT_TYPE_ID,
                         AttachmentPeer.ATTACHMENT_TYPE_ID)
                .add(AttachmentTypePeer.ATTACHMENT_TYPE_ID, 
                     Attachment.URL__PK)
                .add(AttachmentPeer.DELETED, 0);
            result = AttachmentPeer.doSelect(crit);
            putCachedObject(result, GET_URLS);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getExistingAttachments() throws TorqueException
    {
        List result = null;
        Object obj = getCachedObject(GET_EXISTING_ATTACHMENTS); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(AttachmentPeer.ISSUE_ID, getIssueId())
                .addJoin(AttachmentTypePeer.ATTACHMENT_TYPE_ID,
                         AttachmentPeer.ATTACHMENT_TYPE_ID)
                .add(AttachmentTypePeer.ATTACHMENT_TYPE_ID, 
                     Attachment.FILE__PK)
                .add(AttachmentPeer.DELETED, 0);
            result = AttachmentPeer.doSelect(crit);
            putCachedObject(result, GET_EXISTING_ATTACHMENTS);
        }
        else 
        {
            result = (List)obj;
        }
        return result;        
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getActivitiesWithNullEndDate(Attribute attribute)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_NULL_END_DATE, attribute);
        if (obj == null)
        {
            Criteria crit = new Criteria();
            crit.add(ActivityPeer.ISSUE_ID, this.getIssueId());
            crit.add(ActivityPeer.ATTRIBUTE_ID, attribute.getAttributeId());
            crit.add(ActivityPeer.END_DATE, null);
            result = ActivityPeer.doSelect(crit);
            ScarabCache.put(result, this, GET_NULL_END_DATE, attribute);
        }
        else
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public int getHistoryLimit() throws TorqueException
    {
        RModuleIssueType rmit = getModule().getRModuleIssueType(getIssueType());
        if (rmit != null)
        {
            return rmit.getHistory();
        }
        else
        {
            return 5;
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isHistoryLong() throws TorqueException
    {
        return isHistoryLong(getHistoryLimit());
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isHistoryLong(int limit) throws TorqueException
    {
        return (getActivity(true).size() > limit);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getActivity(ScarabUser user) throws TorqueException  
    {
        return getActivity(false, getHistoryLimit(), user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getActivity(int limit, ScarabUser user) throws TorqueException  
    {
        return getActivity(false, limit, user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getActivity(boolean fullHistory, ScarabUser user) throws TorqueException
    {
        return getActivity(fullHistory, getHistoryLimit(), user);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getActivity(boolean fullHistory) throws TorqueException  
    {
        return this.getActivity(fullHistory, null);
    }
            
// in java/org/tigris/scarab/om/Issue.java
private List getActivity(boolean fullHistory, int limit) throws TorqueException
    {
        return this.getActivity(fullHistory, limit, null);
    }
            
// in java/org/tigris/scarab/om/Issue.java
private List getActivity(boolean fullHistory, int limit, ScarabUser user) throws TorqueException  
    {
        List result = null;
        Boolean fullHistoryObj = fullHistory ? Boolean.TRUE : Boolean.FALSE;
        Object obj = getCachedObject(GET_ACTIVITY, fullHistoryObj,
                                     new Integer(limit)); 
        if (obj == null)
        {
            Criteria crit = new Criteria()
                .add(ActivityPeer.ISSUE_ID, getIssueId())
                .addAscendingOrderByColumn(ActivityPeer.TRANSACTION_ID);
            if (!fullHistory)
            {
                crit.setLimit(limit);
            }
            result = ActivityPeer.doSelect(crit);
            putCachedObject(result, GET_ACTIVITY, 
                            fullHistoryObj, new Integer(limit));
        }
        else 
        {
            result = (List)obj;
        }

        /**
         * Filter all activities related to attributegroups restricted to any role
         * to which current user does not belong to.
         * 
         */
        final List visibleActivities = new ArrayList();
        for (Iterator it = result.iterator(); it.hasNext(); )
        {
            final Activity act = (Activity)it.next();
            final Attribute attr = act.getAttribute();
            if (isAttributeVisible(attr, user))
            {
                visibleActivities.add(act);
            }
        }
        return visibleActivities;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void addActivity(Activity activity) throws TorqueException  
    {
        List activityList = null;
        try
        {
            activityList = getActivity(true);
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        super.addActivity(activity);
        if (!activityList.contains(activity))
        {
            activityList.add(activity);
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getActivitySets()
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_TRANSACTIONS);
        if (obj == null)
        {
            Criteria crit = new Criteria();
            crit.add(ActivityPeer.ISSUE_ID, getIssueId());
            crit.addJoin(ActivitySetPeer.TRANSACTION_ID, ActivityPeer.TRANSACTION_ID);
            crit.setDistinct();
            result = ActivitySetPeer.doSelect(crit);
            ScarabCache.put(result, this, GET_TRANSACTIONS);
        }
        else
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isAttributeVisible(final Attribute attr, final ScarabUser user)
        throws TorqueException
    {
        final List/*<AttributeGroup>*/ attrGroups = this.getIssueType().getAttributeGroups();

        boolean foundInAnyGroup = false;
        boolean visibleInFoundGroup = false;
        
        for(Iterator itAny = attrGroups.iterator(); !foundInAnyGroup && itAny.hasNext();)
        {
            final AttributeGroup ag = (AttributeGroup)itAny.next();
            if(getModuleId().equals(ag.getModuleId()) && ag.getAttributes().contains(attr))
            {
                foundInAnyGroup = true;
                if(null == ag.getViewRoleId() || ag.isVisible4User(user))
                {
                    visibleInFoundGroup = true;
                }
            }
        }
        return !foundInAnyGroup || visibleInFoundGroup;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getActivitySet(final ScarabUser user, 
            final Attachment attachment,
            final Integer type)
        throws TorqueException,ScarabException
    {
        ActivitySet activitySet = null;
        if (attachment == null)
        {
            activitySet = ActivitySetManager
                .getInstance(type, user);
        }
        else
        {
            activitySet = ActivitySetManager
                .getInstance(type, user, attachment);
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet getActivitySet(ScarabUser user, Integer type)
        throws TorqueException, ScarabException
    {
        return getActivitySet(user, null, type);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getAllDependencies()
        throws TorqueException
    {
        List dependencies = new ArrayList();
        dependencies.addAll(getChildren());
        dependencies.addAll(getParents());
        return dependencies;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getChildren() throws TorqueException  
    {
        return getChildren(true);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getChildren(boolean hideDeleted) throws TorqueException  
    {
        List result = null;
        Boolean hide = hideDeleted ? Boolean.TRUE : Boolean.FALSE;
        Object obj = getCachedObject(GET_CHILDREN, hide); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(DependPeer.OBSERVED_ID, getIssueId());
            if (hideDeleted)
            {
                crit.add(DependPeer.DELETED, false);
            }
            result = DependPeer.doSelect(crit);
            putCachedObject(result, GET_CHILDREN, hide);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getParents() throws TorqueException  
    {
        return getParents(true);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getParents(boolean hideDeleted) throws TorqueException  
    {
        List result = null;
        Boolean hide = hideDeleted ? Boolean.TRUE : Boolean.FALSE;
        Object obj = getCachedObject(GET_PARENTS, hide); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(DependPeer.OBSERVER_ID, getIssueId());
            if (hideDeleted)
            {
                crit.add(DependPeer.DELETED, false);
            }
            result = DependPeer.doSelect(crit);
            putCachedObject(result, GET_PARENTS, hide);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getAllDependencyTypes() throws TorqueException
    {
        return DependTypeManager.getAll();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doAddDependency(ActivitySet activitySet, Depend depend, 
                                       Issue childIssue, ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check whether the entered issue is already dependent on this
        // Issue. If so, then throw an exception because we don't want
        // to add it again.
        Depend prevDepend = this.getDependency(childIssue, true);
        if (prevDepend != null)
        {
            throw new ScarabException(L10NKeySet.DependencyExists);
        }

        // we definitely want to do an insert here so force it.
        depend.setNew(true);
        depend.setDeleted(false);
        depend.save();

        Attachment comment = depend.getDescriptionAsAttachment(user, this);
        activitySet = attachActivitySet(activitySet, user, comment);

        // Save activity record for the parent issue
        ActivityManager
            .createAddDependencyActivity(this, activitySet, depend);

        // Save activity record for the child issue
        ActivityManager
            .createAddDependencyActivity(childIssue, activitySet, depend);

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Depend getDependency(Issue potentialDependency) throws TorqueException
    {
        return getDependency(potentialDependency, true);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Depend getDependency(Issue potentialDependency, boolean hideDeleted) throws TorqueException
    {
        Depend result = null;
        Object obj = ScarabCache.get(this, GET_DEPENDENCY, potentialDependency);
        if (obj == null)
        {

            // Determine if this issue is a parent to the potentialDependency
            Criteria crit = new Criteria(2)
                .add(DependPeer.OBSERVED_ID, getIssueId())
                .add(DependPeer.OBSERVER_ID, potentialDependency.getIssueId());
            if (hideDeleted)
            {
                crit.add(DependPeer.DELETED, false);
            }

            List childIssues = DependPeer.doSelect(crit);
            // A system invariant is that we will get one and only one
            // record back.
            if (!childIssues.isEmpty())
            {
                result = (Depend)childIssues.get(0);
            }
            else
            {
                // Determine if this issue is a child to the potentialDependency
                Criteria crit2 = new Criteria(2)
                    .add(DependPeer.OBSERVER_ID, getIssueId())
                    .add(DependPeer.OBSERVED_ID, potentialDependency.getIssueId());
                if (hideDeleted)
                {
                    crit2.add(DependPeer.DELETED, false);
                }
                List parentIssues = DependPeer.doSelect(crit2);
                if (!parentIssues.isEmpty())
                {
                    result = (Depend)parentIssues.get(0);
                }
            }

            if (result != null)
            {
                ScarabCache.put(result, this, GET_DEPENDENCY, potentialDependency);
            }
        }
        else
        {
            result = (Depend)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void save(Connection dbCon)
        throws TorqueException
    {
        Module module = getModule();
        if (!module.allowsIssues() || (isNew() && !module.allowsNewIssues())) 
        {
            throw new UnsupportedOperationException(module.getName() + 
                " does not allow issues."); //EXCEPTION
        }
        
        // remove unset AttributeValues before saving
        List attValues = getAttributeValues();
        // reverse order since removing from list
        for (int i=attValues.size()-1; i>=0; i--) 
        {
            AttributeValue attVal = (AttributeValue) attValues.get(i);
            if (!attVal.isSet()) 
            {
                attValues.remove(i);
            }
        }

        if (isNew())
        {
            // set the issue id
            setIdDomain(module.getScarabInstanceId());
            setIdPrefix(module.getCode());

            // for an enter issue template, do not give issue id
            // set id count to -1 so does not show up as an issue
            if (isTemplate())
            { 
                setIdCount(-1);
            }
            else
            {
                try
                {
                    final int suggestedID = getIdCount();
                    if (suggestedID != 0) {
                        // Force the next available issue ID to be the
                        // nominated value, if not out of sequence.
                        // TODO: assert that this issue doesn't already exist
                        // In this case, just skip the next action.
                        setNextIssueId(dbCon, suggestedID);
                    }
                    
                    // Set the ID to the next available value.
                    setIdCount(getNextIssueId(dbCon));
                }
                catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        if(  getActivitySetRelatedByLastTransId()==null
           ||getActivitySetRelatedByCreatedTransId()==null)
        {
            throw new RuntimeException("Created or Last ActivitySet must not be null.");
        }
        super.save(dbCon);
    }
            
// in java/org/tigris/scarab/om/Issue.java
private int getNextIssueId(Connection con)
        throws TorqueException, ScarabException
    {
        int id = -1;
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        try
        {
            id = idbroker.getIdAsInt(con, key);
        }
        catch (Exception e)
        {
            synchronized (idbroker)
            {
                try
                {
                    id = idbroker.getIdAsInt(con, key);
                }
                catch (Exception idRetrievalErr)
                {
                    // a module code entry in the id_table was likely not 
                    // entered, insert a row into the id_table and try again.
                    try
                    {
                        saveIdTableKey(con, 2);
                        id = 1;
                    }
                    catch (Exception badException)
                    {
                        getLog().error("Could not get an id, even after "
                            +"trying to add a module entry into the ID_TABLE", 
                            e);
                        getLog()
                            .error("Error trying to create ID_TABLE entry for "
                                   + getIdTableKey(), badException);
                        // throw the original
                        throw new ScarabException(
                            L10NKeySet.ExceptionRetrievingIssueId,
                            badException);
                    }
                }
            }
        }
        return id;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private void setNextIssueId(Connection con, int newID)
        throws TorqueException, ScarabException
    {
        String key = getIdTableKey();
        DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        IDBroker idbroker = dbMap.getIDBroker();
        int nextID = 1;
        
        synchronized (idbroker)
        {
            try
            {
                // Check if the ID table is available and get the next ID
                nextID = idbroker.getIdAsInt(con, key);
            }
            catch (Exception idRetrievalErr) {
                // No, create the ID table now
                saveIdTableKey(con, nextID);
            }

            if (nextID > newID) {
                getLog()
                    .error("New issue ID "+ newID
                    + "is out of sequence. Must be at least " + nextID);
            }
            else
            {
                try
                {
                    // Now set the next available ID in the table
                    setIdTableKey(con, newID);
                }
                catch (Exception badException)
                {
                    getLog()
                        .error("Error creating ID_TABLE entry for "
                               + getIdTableKey(), badException);
                    // throw the original
                    throw new ScarabException(
                        L10NKeySet.ExceptionRetrievingIssueId,
                        badException);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
private String getIdTableKey()
        throws TorqueException
    {
        Module module = getModule();        
        String prefix = module.getCode();

        String domain = module.getScarabInstanceId();            
        if (domain != null && domain.length() > 0) 
        { 
            prefix = domain + "-" + prefix;
        }
        return prefix;
    }
            
// in java/org/tigris/scarab/om/Issue.java
private void saveIdTableKey(final Connection dbCon, final int nextID)
        throws TorqueException
    {
        int id = 0;
        final DatabaseMap dbMap = IssuePeer.getTableMap().getDatabaseMap();
        final IDBroker idbroker = dbMap.getIDBroker();
        final String idTable = IDBroker.TABLE_NAME.substring(0, 
        IDBroker.TABLE_NAME.indexOf('.'));
        try
        {
            id = idbroker.getIdAsInt(dbCon, idTable);
        }
        catch(Exception e)
        {
            Log.get( getClass().getName() ).error(e);
            throw new TorqueException(e);
        }

        final String key = getIdTableKey();

        // FIXME: UGLY! IDBroker doesn't have a Peer yet.
        final String sql = "insert into " + idTable 
         + " (ID_TABLE_ID,TABLE_NAME,NEXT_ID,QUANTITY) "
         + " VALUES (" + id + ",'" + key + "'," + nextID + ",1)" ;
        BasePeer.executeStatement(sql, dbCon);
    }
            
// in java/org/tigris/scarab/om/Issue.java
private void setIdTableKey(final Connection dbCon, int id)
        throws TorqueException
    {
        final String key = getIdTableKey();

        // FIXME: UGLY! IDBroker doesn't have a Peer yet.
        final String sql = "update ID_TABLE set NEXT_ID=" + id
            + " where TABLE_NAME='" + key + "'";
        BasePeer.executeStatement(sql, dbCon);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public IssueTemplateInfo getTemplateInfo() 
          throws TorqueException
    {
        IssueTemplateInfo result = null;
        Object obj = ScarabCache.get(this, GET_TEMPLATEINFO); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria(1);
            crit.add(IssueTemplateInfoPeer.ISSUE_ID, getIssueId());
            result = (IssueTemplateInfo)IssueTemplateInfoPeer
                .doSelect(crit).get(0);
            ScarabCache.put(result, this, GET_TEMPLATEINFO);
        }
        else 
        {
            result = (IssueTemplateInfo)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getUnsetRequiredAttrs(Module newModule, IssueType newIssueType)
        throws TorqueException
    {
        List attrs = new ArrayList();
        if (!getIssueType().getIssueTypeId()
            .equals(newIssueType.getIssueTypeId())
            || !getModule().getModuleId().equals(newModule.getModuleId()))
        {
            List requiredAttributes = 
                newIssueType.getRequiredAttributes(newModule);
            Map attrValues = getAttributeValuesMap();

            for (Iterator i = requiredAttributes.iterator(); i.hasNext(); )
            {
                Attribute attr = (Attribute)i.next();
                if (!attrValues.containsKey(attr.getName().toUpperCase()))
                {
                    attrs.add(attr);
                }
            }
        }
        return attrs;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Issue move(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user,
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
    	
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // If moving to a new issue type, just change the issue type id
        // otherwise, create fresh issue
        if (getModule().getModuleId().equals(newModule.getModuleId())
            && !getIssueType().getIssueTypeId().equals(newIssueType.getIssueTypeId()))
        {
            newIssue = this;
            newIssue.setIssueType(newIssueType);
            newIssue.save();
        }
        else
        {
            newIssue = newModule.getNewIssue(newIssueType);
        }

        if (newIssue != this)//new issue is not same issue instance as old issue
        {
            // mark issue as moved
            setMoved(true);
            save();

            //add new transaction to new issue
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();      

            // copy attachments: comments/files etc.
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                String oldFilePath = oldA.getFullPath();
                oldA.setIssueId(newIssue.getIssueId());
                oldA.save();
                
                // move file attachment, too
                if (Attachment.FILE__PK.equals(oldA.getTypeId())
                		&& !newIssue.getUniqueId().equals(this.getUniqueId()))
                {
                    try
                    {
                        oldA.copyFileFromTo(oldFilePath, oldA.getFullPath());//copy
                        File f = new File(oldFilePath);//delete old one from disk
                        f.delete();
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }

            // Copy over activity sets for the source issue's previous,
            // and adapt them to new issue
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();

                // If activity set has an attachment, make a copy for new issue
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    // iterate over and move transaction's activities
                    final Activity a = (Activity)j.next();
                    
                    // Only copy transactions that are records of previous move/copies
                    // or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // will be saved when attachments and dependencies are copied.
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                            || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                    	att.setIssueId(newIssue.getIssueId());
                                    	att.setActivity(a);
                                    	att.startActivitySet(as);
                                    	att.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            //adapt all misc activities from old issue
            Iterator iterActivities = getActivitys().iterator();
            while(iterActivities.hasNext()){
            	Activity act = (Activity)iterActivities.next();
            	act.setIssue(newIssue);
            	act.save();
            	newIssue.getActivity(true).add(act); // ?
            }
            
            // Adjust dependencies if its a new issue id
            // (i.e.. moved to new module)
           final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 doDeleteDependency(null, depend, user);
                 
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
        }       
       

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "MovedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());

        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "MovedIssueNote"));
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_MOVED,
                                getUniqueId(), newIssue.getUniqueId());

        newIssue.index();
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_MOVED,
                activitySet2, newIssue, user);
        
        return newIssue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Issue copy(final Module newModule, 
            final IssueType newIssueType, 
            final ScarabUser user, 
            final String reason,
            final List commentAttrs, 
            final List commentUserValues)
          throws TorqueException, ScarabException
    {
        Issue newIssue;

        final Attachment attachment = new Attachment();

        // create fresh issue
        newIssue = newModule.getNewIssue(newIssueType);

        if (newIssue != this)
        {
            ActivitySet createActivitySet = ActivitySetManager.getInstance(
                    ActivitySetTypePeer.CREATE_ISSUE__PK, getCreatedBy());
            createActivitySet.setCreatedDate(getCreatedDate());
            createActivitySet.save();
            newIssue.setCreatedTransId(createActivitySet.getActivitySetId());
            newIssue.save();

            // Copy over activity sets for the source issue's attribute activities
            final List activitySets = getActivitySets();
            final List nonMatchingAttributes = getNonMatchingAttributeValuesList
                                               (newModule, newIssueType);
            final List alreadyAssociatedUsers = new ArrayList();
            for (Iterator i = activitySets.iterator(); i.hasNext();)
            {
                final ActivitySet as = (ActivitySet)i.next();
                ActivitySet newAS = null;
                Attachment newAtt =  null;
                              
                // Copy over activities with sets
                final List activities = as.getActivityList(this);
                for (Iterator j = activities.iterator(); j.hasNext();)
                {
                    final Activity a = (Activity)j.next();

                    // Only copy transactions that are records of previous move/copies
                    // Or transactions relating to attributes.
                    // Other transactions (attachments, dependencies)
                    // Will be saved when attachments and dependencies are copied
                    if (as.getTypeId().equals((ActivitySetTypePeer.MOVE_ISSUE__PK))
                        || !a.getAttributeId().equals(new Integer("0")))
                    {
                        // iterate over and copy transaction's activities
                       
                        if(newAS == null){
                        	
                        	 // If old activity set has an attachment, make a copy for new issue
                            if (as.getAttachmentId() != null)
                            {
                                newAtt = as.getAttachment().copy();
                                newAtt.save();
                            }
                        	
            				//init and store new activity set/transaction
                            newAS = new ActivitySet();
                            newAS.setTypeId(as.getTypeId());
                            if (newAtt != null)
                            {
                                newAS.setAttachmentId(newAtt.getAttachmentId());
                            }
                            newAS.setCreatedBy(as.getCreatedBy());
                            newAS.setCreatedDate(as.getCreatedDate());
                            newAS.save();
                        }
                        
                        final Activity newA = a.copy(newIssue, newAS);
                        
                        newIssue.getActivity(true).add(newA);
                        // If this is an activity relating to setting an attribute value
                        // And the final value is in the issue right now, we'll copy
                        // over the attribute value
                        final AttributeValue attVal = getAttributeValueWithValue(a.getAttribute(),
                                a.getNewValue(), a.getNewNumericValue());
                        if (a.getEndDate() == null && attVal != null)
                        {
                            final List values = getAttributeValues(a.getAttribute());
                            for (Iterator it = values.iterator(); it.hasNext(); )
                            {
                                final AttributeValue att = (AttributeValue)it.next();
                                // Only copy if the target artifact type contains this
                                // Attribute
                                if (attVal != null && !isNonMatchingAttribute(nonMatchingAttributes, att))
                                {
                                    final boolean isUser = (att instanceof UserAttribute);
                                    if (!isUser || !alreadyAssociatedUsers.contains(((UserAttribute)att).getUserName()+att.getAttribute().getName()))
                                    {
                                        final AttributeValue newAttVal = att.copy();
                                        newAttVal.setIssueId(newIssue.getIssueId());                                        
                                        newAttVal.setActivity(newA);
                                        newAttVal.startActivitySet(newAS);
                                        newAttVal.save();
                                        if (isUser)
                                        {
                                            alreadyAssociatedUsers.add(((UserAttribute)att).getUserName()+att.getAttribute().getName());
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            
            // add dependencies newly
            final List children = getChildren();
            for (Iterator i = children.iterator(); i.hasNext();)
            {
                 Depend depend = (Depend)i.next();
                 final Issue child = IssueManager.getInstance(depend.getObserverId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(child.getIssueId());
                 newDepend.setObservedId(newIssue.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 newIssue.doAddDependency(null, newDepend, child, user);
            }
            final List parents = getParents();
            for (Iterator j = parents.iterator(); j.hasNext();)
            {
                 final Depend depend = (Depend)j.next();
                 final Issue parent = IssueManager.getInstance(depend.getObservedId());
                 final Depend newDepend = new Depend();
                 newDepend.setObserverId(newIssue.getIssueId());
                 newDepend.setObservedId(parent.getIssueId());
                 newDepend.setTypeId(depend.getTypeId());
                 parent.doAddDependency(null, newDepend, newIssue, user);
            }
            
            // copy attachments: comments/files etc. and add them, too
            final Iterator attachments = getAttachments().iterator();
            while (attachments.hasNext())
            {
                final Attachment oldA = (Attachment)attachments.next();
                final Attachment newA = oldA.copy();
                newA.setIssueId(newIssue.getIssueId());
                newA.save();
                final Activity oldAct = oldA.getActivity();
                if (oldAct != null)
                {
                    final ActivitySet activitySet = newIssue.attachActivitySet(null, user);
                    ActivityManager.createTextActivity(newIssue, activitySet,
                        ActivityType.getActivityType(oldA.getActivity().getActivityType()), newA);
                }
                if (Attachment.FILE__PK.equals(newA.getTypeId()))
                {
                    try
                    {
                        oldA.copyFileTo(newA.getFullPath());
                    }
                    catch (Exception ex)
                    {
                        throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                    }
                }
            }
        }

        // Generate comment to deal with attributes that do not
        // Exist in destination module, as well as the user attributes.
        final StringBuffer attachmentBuf = new StringBuffer();
        final StringBuffer delAttrsBuf = new StringBuffer();
        if (reason != null && reason.length() > 0)
        {
            attachmentBuf.append(reason).append(". ");
        }
        if (commentAttrs.size() > 0 || commentUserValues.size() > 0 )
        {
            attachmentBuf.append(Localization.format(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(), "DidNotCopyAttributes", newIssueType.getName() + "/" + newModule.getName()));
            attachmentBuf.append("\n");
            for (int i = 0; i < commentAttrs.size(); i++)
            {
                final List attVals = getAttributeValues((Attribute) commentAttrs
                        .get(i));
                for (int j = 0; j < attVals.size(); j++)
                {
                    final AttributeValue attVal = (AttributeValue) attVals.get(j);
                    String field = null;
                    delAttrsBuf.append(attVal.getAttribute().getName());
                    field = attVal.getValue();
                    delAttrsBuf.append("=").append(field).append(". ").append(
                            "\n");
                }
            }
            for (int i=0; i < commentUserValues.size(); i++)
            {
                final UserAttribute useratt = (UserAttribute)commentUserValues.get(i);
                delAttrsBuf.append(useratt.getAttribute().getName() + ": " +
                        useratt.getUserName() + "\n");
            }
           final String delAttrs = delAttrsBuf.toString();
           attachmentBuf.append(delAttrs);

           // Also create a regular comment with non-matching attribute info
           final Attachment comment = new Attachment();
           comment.setTextFields(user, newIssue, Attachment.COMMENT__PK);

           final Object[] args = {this.getUniqueId(), newIssueType.getName() + " / " + newModule.getName()};
           final StringBuffer commentBuf = new StringBuffer(Localization.format(
              ScarabConstants.DEFAULT_BUNDLE_NAME,
              getLocale(),
              "DidNotCopyAttributesFromArtifact", args));
           commentBuf.append("\n").append(delAttrs);
           comment.setData(commentBuf.toString());
           comment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "Comment"));
           comment.save();
        }
        else
        {
            attachmentBuf.append(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "AllCopied"));
        }
        
        attachmentBuf.append(Localization.getString(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CopiedIssueNote"));
        
        attachment.setData(attachmentBuf.toString());


        attachment.setName(Localization.getString(
               ScarabConstants.DEFAULT_BUNDLE_NAME,
               getLocale(),
               "CopiedIssueNote"));
        
        attachment.setTextFields(user, newIssue, Attachment.MODIFICATION__PK);
        attachment.save();

        // Create activitySet for the MoveIssue activity
        // NOTE: There is no distinction bewteen copy and move actions in ActivitySetTypePeer.
        final ActivitySet activitySet2 = 
        	newIssue.attachActivitySet(null, user, attachment, ActivitySetTypePeer.MOVE_ISSUE__PK);

        // Save activity record
        final Attribute zeroAttribute = AttributeManager
            .getInstance(NUMBERKEY_0);
        ActivityManager
            .createTextActivity(newIssue, zeroAttribute, activitySet2,
                                ActivityType.ISSUE_COPIED,
                                getUniqueId(), newIssue.getUniqueId());
        
        //send notification
        NotificationManagerFactory.getInstance().addActivityNotification(
                ActivityType.ISSUE_COPIED,
                activitySet2, newIssue, user);
        
        newIssue.index();
        
        return newIssue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getMatchingAttributeValuesList(Module newModule,
                                               IssueType newIssueType)
          throws TorqueException
    {
        List matchingAttributes = new ArrayList();
        Map setMap = this.getAttributeValuesMap();
        for (Iterator iter = setMap.keySet().iterator(); iter.hasNext();)
        {
            AttributeValue aval = (AttributeValue)setMap.get(iter.next());
            List values = getAttributeValues(aval.getAttribute());
            // loop thru the values for this attribute
            for (int i = 0; i<values.size(); i++)
            {
                AttributeValue attVal = (AttributeValue)values.get(i);
                RModuleAttribute modAttr = newModule.
                    getRModuleAttribute(aval.getAttribute(), newIssueType);

                // If this attribute is active for the destination module,
                // Add to matching attributes list
                if (modAttr != null && modAttr.getActive())
                {
                    // If attribute is an option attribute,
                    // Check if attribute option is active for destination module.
                    if (aval instanceof OptionAttribute)
                    {
                        // FIXME: Use select count
                        Criteria crit2 = new Criteria(4)
                            .add(RModuleOptionPeer.ACTIVE, true)
                            .add(RModuleOptionPeer.OPTION_ID, attVal.getOptionId())
                            .add(RModuleOptionPeer.MODULE_ID, newModule.getModuleId())
                            .add(RModuleOptionPeer.ISSUE_TYPE_ID, newIssueType.getIssueTypeId());
                        List modOpt = RModuleOptionPeer.doSelect(crit2);

                        if (!modOpt.isEmpty())
                        {
                            matchingAttributes.add(attVal);
                        }
                    }
                    else if (attVal instanceof UserAttribute)
                    {
                        ScarabUser user = null;
                        try
                        {
                            user = ScarabUserManager.getInstance(attVal.getUserId());
                        }
                        catch (Exception e)
                        {
                            getLog().error(e);
                            e.printStackTrace();
                        }
                        Attribute attr = attVal.getAttribute();
                        ScarabUser[] userArray = newModule.getUsers(attr.getPermission());
                        // If user exists in destination module with this permission,
                        // Add as matching value
                        if (Arrays.asList(userArray).contains(user))
                        {
                            matchingAttributes.add(attVal);
                        }
                    }
                    else
                    {
                        matchingAttributes.add(attVal);
                    }
                }
            }
        }
        return matchingAttributes;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getMatchingAttributeValuesList(String moduleId, String issueTypeId)
          throws TorqueException
    {
         Module module = ModuleManager.getInstance(new Integer(moduleId));
         IssueType issueType = IssueTypeManager.getInstance(new Integer(issueTypeId));
         return getMatchingAttributeValuesList(module, issueType);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getNonMatchingAttributeValuesList(Module newModule,
                                             IssueType newIssueType)
          throws TorqueException
    {
        List nonMatchingAttributes = new ArrayList();
        AttributeValue aval = null;

        Map setMap = this.getAttributeValuesMap();
        for (Iterator iter = setMap.values().iterator(); iter.hasNext();)
        {
            aval = (AttributeValue) iter.next();
            List values = getAttributeValues(aval.getAttribute());
            // loop thru the values for this attribute
            for (Iterator i = values.iterator(); i.hasNext(); )
            {
                AttributeValue attVal = (AttributeValue) i.next();
                RModuleAttribute modAttr = newModule.
                    getRModuleAttribute(aval.getAttribute(), newIssueType);

                // If this attribute is not active for the destination module,
                // Add to nonMatchingAttributes list
                if (modAttr == null || !modAttr.getActive())
                {
                    nonMatchingAttributes.add(attVal);
                }
                else
                {
                    // If attribute is an option attribute, Check if
                    // attribute option is active for destination module.
                    if (attVal instanceof OptionAttribute)
                    {
                        Criteria crit2 = new Criteria(1)
                            .add(RModuleOptionPeer.ACTIVE, true)
                            .add(RModuleOptionPeer.OPTION_ID, attVal.getOptionId())
                            .add(RModuleOptionPeer.MODULE_ID, newModule.getModuleId())
                            .add(RModuleOptionPeer.ISSUE_TYPE_ID, newIssueType.getIssueTypeId());
                        List modOpt = RModuleOptionPeer.doSelect(crit2);

                        if ( modOpt.isEmpty())
                        {
                                nonMatchingAttributes.add(attVal);
                        }
                    }
                    else if (attVal instanceof UserAttribute)
                    {
                        ScarabUser user = null;
                        try
                        {
                            user = ScarabUserManager.getInstance(attVal.getUserId());
                        }
                        catch (Exception e)
                        {
                            Log.get().error("Unable to retrieve user for "
                                            + "attribute", e);
                        }
                        Attribute attr = attVal.getAttribute();
                        ScarabUser[] userArray =
                            newModule.getUsers(attr.getPermission());
                        // If user exists in destination module with
                        // this permission, add as matching value.
                        if (!Arrays.asList(userArray).contains(user))
                        {
                            nonMatchingAttributes.add(attVal);
                        }
                    }
                }
            }
        }
        return nonMatchingAttributes;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getNonMatchingAttributeValuesList(String moduleId, String issueTypeId)
          throws TorqueException
    {
         Module module = ModuleManager.getInstance(new Integer(moduleId));
         IssueType issueType = IssueTypeManager.getInstance(new Integer(issueTypeId));
         return getNonMatchingAttributeValuesList(module, issueType);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void deleteItem(ScarabUser user)
         throws TorqueException, ScarabException
    {                
        Module module = getModule();
        if (user.hasPermission(ScarabSecurity.ITEM__DELETE, module)
            || (user.getUserId().equals(getCreatedBy().getUserId()) && isTemplate()))
        {
            setDeleted(true);
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/Issue.java
public AttributeValue getDefaultTextAttributeValue()
        throws TorqueException
    {
        AttributeValue result = null;
        Object obj = ScarabCache.get(this, GET_DEFAULT_TEXT_ATTRIBUTEVALUE); 
        if (obj == null) 
        {        
            Attribute defaultTextAttribute = 
                getIssueType().getDefaultTextAttribute(getModule());
            if (defaultTextAttribute != null) 
            {
                result = getAttributeValue(defaultTextAttribute);
            }
            ScarabCache.put(result, this, GET_DEFAULT_TEXT_ATTRIBUTEVALUE);
        }
        else 
        {
            result = (AttributeValue)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public String getDefaultText()
        throws TorqueException
    {
        String result = null;
        Object obj = ScarabCache.get(this, GET_DEFAULT_TEXT); 
        if (obj == null) 
        {        
            AttributeValue emailAV = getDefaultTextAttributeValue();
            if (emailAV != null) 
            {
                result = emailAV.getValue();
            }
            if (result == null) 
            {
                ActivitySet activitySet = getInitialActivitySet();
                if (activitySet != null)
                {
                    Attachment reason = activitySet.getAttachment();
                    if (reason != null && reason.getData() != null 
                        && reason.getData().trim().length() > 0) 
                    {
                        result = reason.getData();
                    }        
                }                
            }
            result = (result == null) ? 
                Localization.getString(ScarabConstants.DEFAULT_BUNDLE_NAME,
                                       getLocale(), "NoIssueSummaryAvailable")
                      : result;
            ScarabCache.put(result, this, GET_DEFAULT_TEXT);
        }
        else 
        {
            result = (String)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet assignUser(ActivitySet activitySet,
                                  final ScarabUser assignee, 
                                  final ScarabUser assigner,
                                  final Attribute attribute, 
                                  final Attachment attachment)
        throws TorqueException,ScarabException
    {                
        final UserAttribute attVal = new UserAttribute();

        activitySet = attachActivitySet(activitySet, assigner, attachment);
        attVal.startActivitySet(activitySet);

        ActivityManager
            .createUserActivity(this, attribute, activitySet,
                                null,
                                null, assignee.getUserId());

        // Save user attribute values
        attVal.setIssue(this);
        attVal.setAttributeId(attribute.getAttributeId());
        attVal.setUserId(assignee.getUserId());
        attVal.setValue(assignee.getUserName());
        attVal.save();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet changeUserAttributeValue(ActivitySet activitySet,
                                                final ScarabUser assignee, 
                                                final ScarabUser assigner, 
                                                final AttributeValue oldAttVal,
                                                final Attribute newAttr,
                                                final Attachment attachment)
        throws TorqueException,ScarabException
    {
        activitySet = attachActivitySet(activitySet, assigner, attachment);
        oldAttVal.startActivitySet(activitySet);

        // Save activity record for deletion of old assignment
        ActivityManager
            .createUserActivity(this, oldAttVal.getAttribute(), 
                                activitySet,
                                null,
                                assignee.getUserId(), null);


        // Save activity record for new assignment
        ActivityManager
            .createUserActivity(this, newAttr, activitySet,
                                null,
                                null, assignee.getUserId());

        // Save assignee value
        oldAttVal.setAttributeId(newAttr.getAttributeId());
        oldAttVal.save();
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet deleteUser(ActivitySet activitySet, 
            final ScarabUser assignee, 
            final ScarabUser assigner,
            final AttributeValue attVal, 
            final Attachment attachment)
        throws TorqueException, ScarabException
    {
        activitySet = attachActivitySet(activitySet, assigner, attachment);
        attVal.startActivitySet(activitySet);

        // Save activity record
        ActivityManager
            .createUserActivity(this, attVal.getAttribute(), 
                                activitySet,
                                null,
                                assignee.getUserId(), null);

        // Save assignee value
        attVal.setDeleted(true);
        attVal.save();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doDeleteDependency(ActivitySet activitySet, 
            Depend oldDepend, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final Issue otherIssue = IssueManager
                        .getInstance(oldDepend.getObserverId(), false);
        final Issue thisIssue = IssueManager
                        .getInstance(oldDepend.getObservedId(), false);

        // get the original object so that we do an update
        oldDepend = thisIssue.getDependency(otherIssue);
        oldDepend.setNew(false);
        oldDepend.setDeleted(true);
        oldDepend.save();

        // need to null out the cache entry so that Issue.getDependency()
        // does not try to return the item from the cache
        ScarabCache.put(null, thisIssue, GET_DEPENDENCY, otherIssue);

        Attachment comment = oldDepend.getDescriptionAsAttachment(user, thisIssue);

        activitySet = thisIssue.attachActivitySet(activitySet, user, comment);
        activitySet = otherIssue.attachActivitySet(activitySet, user, comment);

        ActivityManager
            .createDeleteDependencyActivity(thisIssue, activitySet, oldDepend);
        ActivityManager
            .createDeleteDependencyActivity(otherIssue, activitySet, oldDepend);


        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeUrlDescription(ActivitySet activitySet, 
                                              final ScarabUser user,
                                              final Attachment attachment, 
                                              final String oldDescription)
        throws TorqueException, ScarabException
    {
        final String newDescription = attachment.getName();
        if (!oldDescription.equals(newDescription))
        {
            final Object[] args = {
                oldDescription,
                newDescription,
            };
            String desc = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "UrlDescChangedDesc", args);

            if (desc.length() > 248)
            { 
                desc = desc.substring(0,248) + "...";
            }
            activitySet = attachActivitySet(activitySet, user);
            ActivityManager
                .createTextActivity(this, activitySet,
                                    ActivityType.URL_DESC_CHANGED, attachment,
                                    oldDescription, newDescription);
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_DESC_CHANGED, activitySet, this, user);                
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeUrlUrl(ActivitySet activitySet, 
            final ScarabUser user,
            final Attachment attachment, 
            final String oldUrl)
        throws TorqueException, ScarabException
    {
        final String newUrl = attachment.getData();
        if (!oldUrl.equals(newUrl))
        {
            final Object[] args = {
                oldUrl, newUrl
            };
            String desc = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "UrlChangedDesc", args);

            if (desc.length() > 248)
            { 
                desc = desc.substring(0,248) + "...";
            }
            activitySet = attachActivitySet(activitySet, user);

            // Save activity record
            ActivityManager.createTextActivity(
                    this,
                    activitySet,
                    ActivityType.URL_CHANGED,
                    attachment,
                    oldUrl,
                    newUrl);

            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.URL_CHANGED, activitySet, this, user);            
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doChangeDependencyType(ActivitySet activitySet,
                                              final Depend oldDepend,
                                              final Depend newDepend, 
                                              final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldName = oldDepend.getDependType().getName();
        final String newName = newDepend.getDependType().getName();

        final boolean rolesHaveSwitched = 
            ( oldDepend.getObserverId().equals(newDepend.getObservedId()) &&
              oldDepend.getObservedId().equals(newDepend.getObserverId())
            );
        final boolean typeHasChanged = 
            ( !newName.equals(oldName));
        
        final boolean isActive = !newDepend.getDeleted();
        
        // check to see if something changed
        // only change dependency type for non-deleted deps
        if ( isActive && ( rolesHaveSwitched || typeHasChanged ) )
        {
            final Issue otherIssue = (newDepend.getObservedId().longValue() != this.getIssueId().longValue()
            		? IssueManager.getInstance(newDepend.getObservedId(), false)
            		: IssueManager.getInstance(newDepend.getObserverId(), false));

            // always delete an old dependency
            oldDepend.setDeleted(true);
            oldDepend.save();
            // always create a new dependency
            newDepend.setNew(true);
            newDepend.save();

            // need to null out the cache entry so that Issue.getDependency()
            // does not try to return the item from the cache
            ScarabCache.put(null, this, GET_DEPENDENCY, otherIssue);

            final Attachment comment = newDepend.getDescriptionAsAttachment(user, this);

            activitySet = attachActivitySet(activitySet, user, comment);
            activitySet = otherIssue.attachActivitySet(activitySet, user, comment);
            
            ActivityManager
                .createChangeDependencyActivity(this, activitySet, newDepend,
                                    oldName, newName);
            ActivityManager
                .createChangeDependencyActivity(otherIssue, activitySet, newDepend,
                                    oldName, newName);
        }
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setInitialAttributeValues(ActivitySet activitySet, 
            Attachment attachment, 
            final HashMap newValues, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        // Check new values for workflow
        final String msg = doCheckInitialAttributeValueWorkflow(newValues, user);
        if (msg != null)
        {
            throw new TorqueException(msg); //EXCEPTION
        }
        
        if (activitySet == null)
        {
            // Save activitySet record
            activitySet = ActivitySetManager
                .getInstance(ActivitySetTypePeer.CREATE_ISSUE__PK, user);
            activitySet.save();
        }
        setActivitySetRelatedByCreatedTransId(activitySet);

        // enter the values into the activitySet
        final LinkedMap avMap = getModuleAttributeValuesMap(); 
        final MapIterator iter = avMap.mapIterator();
        while (iter.hasNext())
        {
            final AttributeValue aval = (AttributeValue)avMap.get(iter.next());
            try
            {
                aval.startActivitySet(activitySet);
            }
            catch (ScarabException se)
            {
                L10NMessage l10nmsg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,se);
                throw new ScarabException(l10nmsg);
            }
        }        
        this.save();

        // create initial issue creation activity
        ActivityManager.createReportIssueActivity(this, activitySet,  
                Localization.getString(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueCreated"));

        // this needs to be done after the issue is created.
        // check to make sure the attachment has data before submitting it.
        final String attachmentData = attachment.getData();
        if (attachmentData != null &&
            attachmentData.length() > 0)
        {
            attachment = AttachmentManager.getReason(attachment, this, user);
            activitySet.setAttachment(attachment);
        }
        activitySet.save();
        
        // need to clear the cache since this is after the 
        // issue is saved. for some reason, things don't
        // show up properly right away.
        ScarabCache.clear();
        
        index();
        
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet setAttributeValues(ActivitySet activitySet,
                                          final HashMap newAttVals,
                                          final Attachment attachment,
                                          final ScarabUser user)
        throws TorqueException,ScarabException
    {
        if (!isTemplate())
        {
            final String msg = doCheckAttributeValueWorkflow(newAttVals, user);
            if (msg != null)
            {
                throw new ScarabException(L10NKeySet.ErrorExceptionMessage,msg); 
            }
        }
        if (attachment != null)
        {
            attachment.setTextFields(user, this, 
                                     Attachment.MODIFICATION__PK);
            attachment.save();
        }
        activitySet = attachActivitySet(activitySet, user, attachment );
        
        final LinkedMap avMap = getModuleAttributeValuesMap(true); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            final String newAttValValue = newAttVal.getValue();

            if (oldAttVal != null &&
            		(newAttValValue != null && !newAttValValue.equals(oldAttVal.getValue())
            		 || newAttValValue == null)
            		 )
            {
                if (newAttValValue != null && newAttValValue.length() > 0)
                {
                    oldAttVal.setProperties(newAttVal);
                }
                else
                {
                    oldAttVal.setDeleted(true);
                }
                oldAttVal.startActivitySet(activitySet);
                oldAttVal.save();
            }
        }
        index();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
       ActivitySet activitySet,
       final ScarabUser user,
       final Attachment attachment,
       final Integer activitySetType 
    )
       throws TorqueException,ScarabException
    {
        if (activitySet == null)
        {
            activitySet = getActivitySet(
               user, attachment,
               activitySetType);
            activitySet.save();
            ScarabCache.clear();
        }

        setLastTransId(activitySet.getActivitySetId());
        save();
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
        ActivitySet activitySet,
        final ScarabUser user,
        final Attachment attachment
    )
        throws TorqueException,ScarabException
    {
        return attachActivitySet(activitySet, user, attachment, ActivitySetTypePeer.EDIT_ISSUE__PK);
    }
            
// in java/org/tigris/scarab/om/Issue.java
protected ActivitySet attachActivitySet( 
        ActivitySet activitySet,
        final ScarabUser user
    )
        throws TorqueException,ScarabException
    {
        return attachActivitySet(activitySet, user, null, ActivitySetTypePeer.EDIT_ISSUE__PK);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public String doCheckInitialAttributeValueWorkflow(final HashMap newValues, 
                                                       final ScarabUser user)
        throws TorqueException, ScarabException
    {
        String msg = null;
        final Iterator iter = newValues.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            if (attr.isOptionAttribute())
            {
                final AttributeOption toOption = AttributeOptionManager
                     .getInstance(new Integer((String)newValues.get(attrId)));
                msg = WorkflowFactory.getInstance().checkInitialTransition(
                                                    toOption, this, 
                                                    newValues, user);
            }
            if (msg != null)
            {
                break;
            }
        }
        return msg;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public String doCheckAttributeValueWorkflow(final HashMap newAttVals, 
                                                final ScarabUser user)
        throws TorqueException,ScarabException
    {
    	final LinkedMap avMap = getModuleAttributeValuesMap(); 
        AttributeValue oldAttVal = null;
        AttributeValue newAttVal = null;
        String msg = null;
        final Iterator iter = newAttVals.keySet().iterator();
        while (iter.hasNext())
        {
            final Integer attrId = (Integer)iter.next();
            final Attribute attr = AttributeManager.getInstance(attrId);
            oldAttVal = (AttributeValue)avMap.get(attr.getName().toUpperCase());
            newAttVal = (AttributeValue)newAttVals.get(attrId);
            AttributeOption fromOption = null;
            AttributeOption toOption = null;

            if (newAttVal.getValue() != null)
            {
                if (newAttVal.getAttribute().isOptionAttribute())
                {
                    if (oldAttVal.getOptionId() == null)
                    {
                        fromOption = AttributeOptionManager.getInstance(ScarabConstants.INTEGER_0);
                    }
                    else
                    {
                        fromOption = oldAttVal.getAttributeOption();
                    }
                    toOption = newAttVal.getAttributeOption();
                    msg = WorkflowFactory.getInstance().checkTransition(
                                                        fromOption, 
                                                        toOption, this, 
                                                        newAttVals, user);
                }
                if (msg != null)
                {
                    break;
                }
            }
        }
        return msg;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doEditComment(ActivitySet activitySet, 
            final String newComment, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldComment = attachment.getData();
        if (!newComment.equals(oldComment)) 
        {
            attachment.setData(newComment);
            attachment.save();
           
            activitySet = attachActivitySet( activitySet, user);
            // Save activity record
            ActivityManager
                .createTextActivity(this, null, activitySet,
                                    ActivityType.COMMENT_CHANGED, null, attachment,
                                    oldComment, newComment);
             
            NotificationManagerFactory.getInstance().addActivityNotification(
                    ActivityType.COMMENT_CHANGED, activitySet,
                    this, user);            
        }
        index();

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doDeleteUrl(ActivitySet activitySet, 
            final Attachment attachment, 
            final ScarabUser user)
        throws TorqueException, ScarabException
    {
        final String oldUrl = attachment.getData();
        attachment.setDeleted(true);
        attachment.save();

        activitySet = attachActivitySet( activitySet, user);

        // Save activity record
        ActivityManager
            .createTextActivity(this, null, activitySet,
                                ActivityType.URL_DELETED, null, attachment, oldUrl, null);
        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ActivitySet doRemoveAttachment(ActivitySet activitySet,
                                          final MutableBoolean physicallyDeleted,
                                          final Attachment attachment, 
                                          final ScarabUser user)
        throws TorqueException, ScarabException
    {
        boolean attachmentPhysicallyDeleted = false;
        final boolean physicalDeletionAllowed = Turbine.getConfiguration()
        .getBoolean("scarab.attachment.remove.permanent",false);

        if(physicalDeletionAllowed)
        {
            attachmentPhysicallyDeleted = attachment.deletePhysicalAttachment();
            physicallyDeleted.set(attachmentPhysicallyDeleted);
        }

        attachment.setDeleted(true);
        attachment.save();

        activitySet = attachActivitySet(activitySet, user);
        
        // Save activity record
        ActivityManager
            .createTextActivity(this, null, activitySet,
                    ActivityType.ATTACHMENT_REMOVED, null, attachment, attachment.getFileName(), null);

        return activitySet;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public HashSet getAssociatedUsers() throws TorqueException
    {
        HashSet users = null;
        final Object obj = ScarabCache.get(this, GET_ASSOCIATED_USERS); 
        if (obj == null) 
        {        
            final List attributeList = getModule()
                .getUserAttributes(getIssueType(), true);
            final List attributeIdList = new ArrayList();
            
            for (int i=0; i<attributeList.size(); i++) 
            {
                final Attribute att = (Attribute) attributeList.get(i);
                final RModuleAttribute modAttr = getModule().
                    getRModuleAttribute(att, getIssueType());
                if (modAttr.getActive())
                {
                    attributeIdList.add(att.getAttributeId());
                }
            }
            
            if (!attributeIdList.isEmpty())
            {
                users = new HashSet();
                final Criteria crit = new Criteria()
                    .addIn(AttributeValuePeer.ATTRIBUTE_ID, attributeIdList)
                    .add(AttributeValuePeer.DELETED, false);
                crit.setDistinct();
                
                final List attValues = getAttributeValues(crit);
                for (int i=0; i<attValues.size(); i++) 
                {
                    final List item = new ArrayList(2);
                    final AttributeValue attVal = (AttributeValue) attValues.get(i);
                    final ScarabUser su = ScarabUserManager.getInstance(attVal.getUserId());
                    final Attribute attr = AttributeManager.getInstance(attVal.getAttributeId());
                    item.add(attr);
                    item.add(su);
                    users.add(item);
                }
            }
            ScarabCache.put(users, this, GET_ASSOCIATED_USERS);
        }
        else 
        {
            users = (HashSet)obj;
        }
        return users;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlockingConditionTrue() throws TorqueException
    {
       boolean isBlockingConditionTrue = false;
       final List blockingConditions = this.getRModuleIssueType().getConditions();
       for (Iterator it = blockingConditions.iterator(); !isBlockingConditionTrue && it.hasNext(); )
       {
           final Condition cond = (Condition)it.next();
           isBlockingConditionTrue = cond.evaluate(null, this);
           // Will exit as soon as any evaluates true!
       }
       return isBlockingConditionTrue;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlockingAnyIssue() throws TorqueException
    {
       return this.getBlockedIssues().size() > 0; 
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlocked() throws TorqueException
    {
        return (getBlockingIssues().size()>0);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlockedBy(final String blockingId) throws TorqueException
    {
        final List blockingIssues = getBlockingIssues();
        int issueCount = getBlockingIssues().size();
        if (issueCount==0)
        {
            return false;
        }
        
        for(int index = 0; index < issueCount; index++)
        {
            final Issue issue = (Issue)blockingIssues.get(index);
            final String id = issue.getUniqueId();
            if(id.equals(blockingId))
            {
                return true;
            }
        }
        return false;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isBlocking(final String blockedId) throws TorqueException
    {
        final List blockedIssues = getBlockedIssues();
        final int issueCount = blockedIssues.size();
        if (issueCount==0)
        {
            return false;
        }
        
        for(int index = 0; index < issueCount; index++)
        {
            final Issue issue = (Issue)blockedIssues.get(index);
            final String id = issue.getUniqueId();
            if(id.equals(blockedId))
            {
                return true;
            }
        }
        return false;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getBlockingIssues() throws TorqueException
    {
        final List blockingIssues = new ArrayList();
        final List prerequisiteIssues = this.getPrerequisiteIssues();
        for (Iterator it = prerequisiteIssues.iterator(); it.hasNext(); )
        {
            final Issue is = (Issue)it.next();
            if (is.isBlockingConditionTrue())
                blockingIssues.add(is);
        }        
        return blockingIssues;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getPrerequisiteIssues() throws TorqueException
    {
        final List blockingIssues = new ArrayList();
        final List parentIssues = this.getParents();
        for (Iterator it = parentIssues.iterator(); it.hasNext(); )
        {
            final Depend depend = (Depend)it.next();
            if (depend.getDependType().getDependTypeId().equals(DependTypePeer.BLOCKING__PK))
            {
                blockingIssues.add(IssuePeer.retrieveByPK(depend.getObservedId()));
            }
        }        
        return blockingIssues;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getRelatedIssues() throws TorqueException
    {
        return getAssociatedIssues(DependTypePeer.NON_BLOCKING__PK);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getDuplicateIssues() throws TorqueException
    {
        return getAssociatedIssues(DependTypePeer.DUPLICATE__PK);
    }
            
// in java/org/tigris/scarab/om/Issue.java
private List getAssociatedIssues(final Integer dependTypeId) throws TorqueException
    {
        final List relatedIssues = new ArrayList();
        final List allIssues = this.getAllDependencies();
        for (Iterator it = allIssues.iterator(); it.hasNext(); )
        {
            final Depend depend   = (Depend)it.next();
            final DependType type = depend.getDependType();
            final Integer typeId  = type.getDependTypeId();
            if (typeId.equals(dependTypeId))
            {
                //Assume, the dependant issue is the ObservedId in the Depend
                Issue relatedIssue = IssuePeer.retrieveByPK(depend.getObservedId());
                if(relatedIssue.getIssueId().equals(this.getIssueId()))
                {
                    //No, the dependant issue is the ObserverId in the depend.
                    relatedIssue = IssuePeer.retrieveByPK(depend.getObserverId());
                }
                relatedIssues.add(relatedIssue);
            }
        }        
        return relatedIssues;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getBlockedIssues() throws TorqueException
    {
        if (this.isBlockingConditionTrue())
        {
            return this.getDependantIssues();
        }
        else
        {
            return new ArrayList();
        }
    }
            
// in java/org/tigris/scarab/om/Issue.java
public List getDependantIssues() throws TorqueException
    {
        final List dependantIssues = new ArrayList();
        final List childIssues = this.getChildren();
        for (Iterator it = childIssues.iterator(); it.hasNext(); )
        {
            final Depend depend = (Depend)it.next();
            if (depend.getDependType().getDependTypeId().equals(DependTypePeer.BLOCKING__PK))
            {
                dependantIssues.add(IssuePeer.retrieveByPK(depend.getObserverId()));
            }
        }
        return dependantIssues;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public String getIssueNewId() throws TorqueException
    {
        return ActivityPeer.getNewIssueUniqueId(this);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void setCreatedTransId(Long createdTransId) 
        throws TorqueException
    {
        super.setCreatedTransId(createdTransId);
        if(super.getLastTransId()==null)
            super.setLastTransId(createdTransId);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isRequiredAttributeFor(Attribute attribute, ScarabUser user) throws TorqueException, ScarabException
    {
        Module module         = this.getModule();
        IssueType issueType   = this.getIssueType();
        RModuleAttribute rma  = module.getRModuleAttribute(attribute, issueType);

        boolean result = rma.getRequired();
        if(result == false)
        {
            List<Condition> conditions = rma.getConditions();
                
            Iterator<Condition> iter = conditions.iterator();
            while(iter.hasNext())
            {
                Condition condition = iter.next();
                boolean eval = condition.evaluate(user, this);
                result |= eval;
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Attribute getAttribute(String attributeName) throws TorqueException 
    {
        Attribute result = null;
        List<Attribute> attributes = this.getIssueType().getActiveAttributes(getModule());
        Iterator<Attribute> iter = attributes.iterator();
        while(iter.hasNext())
        {
            Attribute attrib = iter.next();
            String attribName = attrib.getName();
            if(attribName.equals(attributeName))
            {
                result = attrib;
                break;
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/Issue.java
public SkipFiltering createIssueChecker(String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        return mystate.createIssueChecker(setMarkerFunction, indent);
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isSealed() throws TorqueException
    {        
        return mystate.isSealed();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public boolean isOnHold() throws TorqueException
    {        
        return mystate.isOnHold();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Attribute getMyStatusAttribute() throws TorqueException
    {
        return mystate.getStatusAttribute();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Attribute getMyOnHoldExpirationDate() throws TorqueException
    {
        return mystate.getOnHoldExpirationDate();
    }
            
// in java/org/tigris/scarab/om/Issue.java
public Date getOnHoldUntil() throws TorqueException, ParseException
    {
        return mystate.getOnHoldUntil();
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public void setActivityList(List activityList)
        throws TorqueException
    {
        for (Iterator itr = activityList.iterator();itr.hasNext();)
        {
            Activity activity = (Activity) itr.next();
            activity.setActivitySet(this);
            activity.save();
        }
        ScarabCache.put(activityList, this, GET_ACTIVITY_LIST);
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public List getActivityList(Issue issue) throws TorqueException
    {
         List activityList = (List)ActivitySetManager.getMethodResult()
                .get(this, GET_ACTIVITY_LIST, issue );

        if(activityList==null)
        {
            Criteria crit = new Criteria()
                .add(ActivityPeer.TRANSACTION_ID, getActivitySetId())
                .add(ActivityPeer.ISSUE_ID, issue.getIssueId());
            activityList = ActivityPeer.doSelect(crit);

            ActivitySetManager.getMethodResult()
                .put(activityList, this, GET_ACTIVITY_LIST, issue );
        }
        return activityList;  
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public ScarabUser getCreator()
        throws TorqueException
    {
        return getScarabUser();
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public String getActivityReason() throws TorqueException
    {
        Attachment attachment = this.getAttachment();
        return attachment!=null ? attachment.getData() : "";
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public Set getRemovedUsers(Issue changedIssue) throws TorqueException
    {
        Set removedUsers = new HashSet();
        for (Iterator it = getActivityList(changedIssue).iterator(); it.hasNext(); )
        {
            Activity act = (Activity)it.next();
            if(act.getOldUserId() != null && act.getNewUserId() == null)
            {
                ScarabUser removedUser = ScarabUserManager.getInstance(act.getOldUserId());
                removedUsers.add(removedUser);
            }
        }
        return removedUsers;
    }
            
// in java/org/tigris/scarab/om/ActivitySet.java
public boolean hasTransitionSealed() throws ScarabException, TorqueException 
    {
        boolean result = false;
        String status = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if (status != null)
        {
            String value = Environment.getConfigurationProperty("scarab.common.status.sealed", null);
            if(value != null)
            {
                
                List<Activity> activities = getActivityList();
                if (activities != null)
                {
                    Iterator<Activity> iter = activities.iterator();
                    if (iter != null)
                    {
                        Activity act = null;
                        try
                        {
                            while((act = iter.next()) != null)
                            {
                                ActivityType at = ActivityType.getActivityType(act.getActivityType());
                                if(at == ActivityType.ATTRIBUTE_CHANGED)
                                {
                                    Attribute att = act.getAttribute();
                                    String name = att.getName();
                                    if(name.equals(status))
                                    {
                                       String oldv = act.getOldValue();
                                       String newv = act.getNewValue();
                                       
                                       if(value.equals(oldv) || value.equals(newv))
                                       {
                                           result = true;
                                           break;
                                       }
                                    }
                                }
                            }
                        }
                        catch (NoSuchElementException nsee)
                        {
                            Throwable th = new Throwable("No such element exception occured.(ignore and assume transitionToSealed=false)");
                            th.printStackTrace();
                            result = false;
                        }
                    }
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
protected List getRModuleUserAttributes(Criteria crit)
                throws TorqueException
            {
                return getPrivateRModuleUserAttributes(crit);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasPermission(String perm, Module module)
               throws TorqueException
            {
                return hasPrivatePermission(perm, module);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
protected void deleteRModuleUserAttribute(final RModuleUserAttribute rmua)
                throws TorqueException, TurbineSecurityException
            {
                privateDeleteRModuleUserAttribute(rmua);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private List getPrivateRModuleUserAttributes(Criteria crit)
        throws TorqueException
    {
        return getRModuleUserAttributes(crit);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private boolean hasPrivatePermission(String perm, Module module)
        throws TorqueException
    {
        return hasPermission(perm, module);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private void privateDeleteRModuleUserAttribute(final RModuleUserAttribute rmua)
        throws TorqueException, TurbineSecurityException
    {
        rmua.delete(this);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasPermission(String perm, Module module)
        throws TorqueException
    {
        if (perm.equals(ScarabSecurity.USER__CHANGE_PASSWORD) && isUserAnonymous())
        {
            return false;
        }

        if (module == null || ScarabSecurity.DOMAIN__ADMIN.equals(perm) || ScarabSecurity.DOMAIN__EDIT.equals(perm))
        {
            module = ModuleManager.getInstance(Module.ROOT_ID);
        }

        AccessControlList aclAnonymous = null;
        if (ScarabUserManager.anonymousAccessAllowed())
        {
            aclAnonymous = ScarabUserManager.getAnonymousUser().getACL();
        }
        
        boolean hasPermission = false;

        AccessControlList acl = this.getACL();
        if (acl != null) 
        {
            hasPermission = aclHasPermission(acl, perm, module);
        }                        
        if (!hasPermission && aclAnonymous != null)
        {
            hasPermission = aclHasPermission(aclAnonymous, perm, module);
        }
        
        return hasPermission;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasPermission(String perm, List modules) throws TorqueException
    {
        return internalUser.hasPermission(perm, modules);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getModules() throws TorqueException
    {
        return internalUser.getModules();
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getModules(boolean showDeletedModules)
        throws TorqueException
    {
        return internalUser.getModules(showDeletedModules);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public Module[] getModules(String permission) throws TorqueException
    {
        return internalUser.getModules(permission);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getCopyToModules(Module currentModule) throws TorqueException
    {        
         return internalUser.getCopyToModules(currentModule);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getCopyToModules(Module currentModule, String action) throws TorqueException
    {        
         return internalUser.getCopyToModules(currentModule, action, null);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getCopyToModules(Module currentModule, String action, 
                                 String searchString)
        throws TorqueException
    {        
         return internalUser.getCopyToModules(currentModule, action, searchString);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasAnyRoleIn(Module module)
        throws TorqueException
    {
        return getRoles(module).size() != 0;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private List getRoles(Module module)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_ROLES, module); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.setDistinct();
            crit.add(TurbineUserGroupRolePeer.USER_ID, getUserId());
            crit.add(TurbineUserGroupRolePeer.GROUP_ID, module.getModuleId());
            crit.addJoin(TurbineRolePeer.ROLE_ID, 
                     TurbineUserGroupRolePeer.ROLE_ID);
            result = TurbineRolePeer.doSelect(crit);
            
            ScarabCache.put(result, this, GET_ROLES, module);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void createNewUser()
        throws TorqueException, DataBackendException, EntityExistsException
    {
        // get a unique id for validating the user
        final String uniqueId = RandomStringUtils
                .randomAlphanumeric(UNIQUE_ID_MAX_LEN);
        // add it to the perm table
        setConfirmed(uniqueId);
        TurbineSecurity.addUser (this, getPassword());
        setPasswordExpire();
        
        // add any roles the anonymous user has, if she is enabled.
        if(ScarabUserManager.anonymousAccessAllowed())
        {
            final ScarabUserImpl anonymous = (ScarabUserImpl) ScarabUserManager.getAnonymousUser();
            final List/*<ScarabModule>*/ modules = anonymous.getNonGlobalModules();
            for(Iterator it0 = modules.iterator(); it0.hasNext(); )
            {
                final ScarabModule module = (ScarabModule)it0.next();
                final List/*<Roles>*/ roles = anonymous.getRoles(module);
                for(Iterator it1 = roles.iterator(); it1.hasNext(); )
                {
                    try 
                    {
                        final Role role = (Role) it1.next();
                        TurbineSecurity.grant(this, (Group) module, role);

                        // TODO: Needs to be refactored into the Users system?
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.GET_ACL);
                        ScarabUserManager.getMethodResult()
                                .remove(this, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable) role, module);
                        
                    }catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getEditableModules() throws TorqueException
    {
        return internalUser.getEditableModules();
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getEditableModules(Module currEditModule)
        throws TorqueException
    {
        return internalUser.getEditableModules(currEditModule);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getNonGlobalModules() throws TorqueException
    {
        List modules = new ArrayList();
        for (Iterator it = internalUser.getModules().iterator(); it.hasNext(); )
        {
            Module m = (Module)it.next();
            if (!m.isGlobalModule())
            {
                modules.add(m);
            }
        }
        return modules;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getRModuleUserAttributes(Module module,
                                         IssueType issueType)
        throws TorqueException
    {
        return internalUser.getRModuleUserAttributes(module, issueType);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                        final Attribute attribute,
                                                        final IssueType issueType)
        throws TorqueException, ScarabException
    {
        return internalUser
            .getRModuleUserAttribute(module, attribute, issueType);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setPasswordExpire()
        throws TorqueException
    {
        String expireDays = Turbine.getConfiguration()
            .getString("scarab.login.password.expire", null);
        
        if (expireDays == null || expireDays.trim().length() == 0)
        {
            setPasswordExpire(null);
        }
        else
        {
            Calendar expireDate = Calendar.getInstance();
            expireDate.add(Calendar.DATE, Integer.parseInt(expireDays));
            setPasswordExpire(expireDate);
        }
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setPasswordExpire(Calendar expire)
        throws TorqueException
    {
        Integer userid = getUserId();
        if (userid == null)
        {
            throw new TorqueException("Userid cannot be null"); //EXCEPTION
        }
        UserPreference up = UserPreferenceManager.getInstance(getUserId());
        if (expire == null)
        {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + 10);
            up.setPasswordExpire(cal.getTime());
        }
        else
        {
            up.setPasswordExpire(expire.getTime());
        }
        up.save();
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean isPasswordExpired()
        throws TorqueException
    {
        // Password for anonymous never expires.
        if (isUserAnonymous())
        {
            return false;
        }
        
        final Integer userid = getUserId();
        if (userid == null)
        {
            return false; // throw new ScarabException (L10NKeySet.ExceptionGeneral,"Userid cannot be null"); //EXCEPTION
        }
        final Criteria crit = new Criteria();
        crit.add(UserPreferencePeer.USER_ID, userid);
        final Calendar cal = Calendar.getInstance();
        crit.add(UserPreferencePeer.PASSWORD_EXPIRE, 
                 cal.getTime() , Criteria.LESS_THAN);
        final List result = UserPreferencePeer.doSelect(crit);
        return result.size() == 1 ? true : false;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean isUserAnonymous()
        throws TorqueException
    {
        boolean brdo = false;
        String anonymous = ScarabUserManager.getAnonymousUserName();
        if (ScarabUserManager.anonymousAccessAllowed() &&
            anonymous != null && getUserName().equals(anonymous))
        {
            brdo = true;
        }
        return brdo;
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public int getEnterIssueRedirect()
        throws TorqueException
    {
        return internalUser.getEnterIssueRedirect();
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setEnterIssueRedirect(int templateCode)
        throws TorqueException
    {
        internalUser.setEnterIssueRedirect(templateCode);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public  String getDefaultQueryId(Module module) throws TorqueException
    {
        return internalUser.getDefaultQueryId(module);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void setHomePage(String homePage)
        throws TorqueException, ScarabException
    {
        internalUser.setHomePage(homePage);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getMITLists()
        throws TorqueException
    {
        return internalUser.getMITLists();
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public boolean hasAnySearchableRMITs()
        throws TorqueException, DataSetException    
    {
        return internalUser.hasAnySearchableRMITs();
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getSearchableRMITs(String searchField, String searchString, 
                                   String sortColumn, String sortPolarity,
                                   Module skipModule)
        throws TorqueException    
    {
        return internalUser.getSearchableRMITs(searchField, searchString, 
            sortColumn, sortPolarity, skipModule);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getUnusedRModuleIssueTypes(Module module)
        throws TorqueException
    {
        return internalUser.getUnusedRModuleIssueTypes(module);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public List getAllRModuleIssueTypes(Module module)
        throws TorqueException
    {
        return internalUser.getAllRModuleIssueTypes(module);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void addRMITsToCurrentMITList(List rmits)
        throws TorqueException
    {
        internalUser.addRMITsToCurrentMITList(rmits);
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public RModuleIssueType getCurrentRModuleIssueType()
        throws TorqueException
    {
        return internalUser.getCurrentRModuleIssueType();
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
public void updateIssueListAttributes(List attributes)
        throws TorqueException
    {
        internalUser.updateIssueListAttributes(attributes);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public boolean hasPermission(String perm, List modules) throws TorqueException
    {
        boolean hasPerm = false;
        if (modules != null && !modules.isEmpty()) 
        {
            hasPerm = true;
            Iterator i = modules.iterator();
            while (i.hasNext() && hasPerm) 
            {
                hasPerm = hasPermission(perm, (Module)i.next());
            }
        }
        return hasPerm;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getEditableModules()
        throws TorqueException
    {
        return getEditableModules(null);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getCopyToModules(Module currentModule, String action, 
                                 String searchString)
        throws TorqueException
    {
        List copyToModules = new ArrayList();
        if (hasPermission(ScarabSecurity.ISSUE__MOVE, currentModule) 
            || "copy".equals(action))
        {
            Module[] userModules = getModules(ScarabSecurity.ISSUE__ENTER);
            for (int i=0; i<userModules.length; i++)
            {
                Module module = userModules[i];
                if (!module.isGlobalModule() && 
                    (searchString == null || searchString.equals("") || 
                     module.getName().indexOf(searchString) != -1))
                {
                    copyToModules.add(module);
                }
            }
        }
        else if (hasPermission(ScarabSecurity.ISSUE__EDIT, currentModule)
                 && currentModule.getIssueTypes().size() > 1)
        {
            copyToModules.add(currentModule);
        }
        return copyToModules;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getCopyToModules(Module currentModule)
        throws TorqueException
    {
        return getCopyToModules(currentModule, "copy", null);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getCopyToModules(Module currentModule, String action)
        throws TorqueException
    {
        return getCopyToModules(currentModule, action, null);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getEditableModules(Module currEditModule)
        throws TorqueException
    {
        List userModules = getModules(true);
        List editModules = new ArrayList();

        if (currEditModule != null && currEditModule.getParent().getModuleId().intValue() != 0)
        {
            editModules.add(currEditModule.getParent());
        }
        for (int i=0; i<userModules.size(); i++)
        {
            Module module = (Module)userModules.get(i);
            Module parent = module.getParent();

            if (!editModules.contains(module) && parent != currEditModule)
            {
                if (hasPermission(ScarabSecurity.MODULE__EDIT, module) && module.getModuleId().intValue() != 0)
                {
                    editModules.add(module);
                }
            }
        }
        // we want to remove the module we are editing
        if (currEditModule != null && editModules.contains(currEditModule))
        {
            editModules.remove(currEditModule);
        }

        return editModules;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getRModuleUserAttributes(Module module,
                                         IssueType issueType)
        throws TorqueException
    {
        List result = null;
        Object obj = ScarabCache.get(this, GET_R_MODULE_USERATTRIBUTES, 
                                     module, issueType); 
        if (obj == null) 
        {
            Integer moduleId    = module.getModuleId();
            Integer userId      = getUserId();
            Integer issueTypeId = issueType.getIssueTypeId();
            Criteria crit = new Criteria()
                .add(RModuleUserAttributePeer.USER_ID,       userId)
                .add(RModuleUserAttributePeer.MODULE_ID,     moduleId)
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, issueTypeId)
                .addAscendingOrderByColumn(RModuleUserAttributePeer.PREFERRED_ORDER);
            
            result = getRModuleUserAttributes(crit);
            ScarabCache.put(result, this, GET_R_MODULE_USERATTRIBUTES,  
                            module, issueType);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public RModuleUserAttribute getRModuleUserAttribute(final Module module, 
                                                       final Attribute attribute,
                                                       final IssueType issueType)
        throws TorqueException, ScarabException
    {
        RModuleUserAttribute result = null;
        final Object obj = ScarabCache.get(this, GET_R_MODULE_USERATTRIBUTE, 
                                     module, attribute, issueType); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria(4)
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId())
                .add(RModuleUserAttributePeer.LIST_ID, null);
            if (module == null) 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.MODULE_ID, 
                         module.getModuleId());
                
            }            
            if (issueType == null) 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, null);
            }
            else 
            {
                crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, 
                         issueType.getIssueTypeId());                
            }
            
            final List muas = RModuleUserAttributePeer.doSelect(crit);
            if (muas.size() == 1) 
            {
                result = (RModuleUserAttribute)muas.get(0);
            }
            else if (muas.isEmpty())
            {
                result = 
                    getNewRModuleUserAttribute(attribute, module, issueType);
            }
            else 
            {
                throw new ScarabException(L10NKeySet.ExceptionMultipleJDMs);
            }
            ScarabCache.put(result, this, GET_R_MODULE_USERATTRIBUTE, 
                            module, attribute, issueType);
        }
        else 
        {
            result = (RModuleUserAttribute)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
protected RModuleUserAttribute getNewRModuleUserAttribute(
        Attribute attribute, Module module, IssueType issueType)
        throws TorqueException
    {
        RModuleUserAttribute result = RModuleUserAttributeManager.getInstance();
        result.setUserId(getUserId());
        result.setAttributeId(attribute.getAttributeId());
        if (module != null) 
        {
            result.setModuleId(module.getModuleId());
        }
        if (issueType != null) 
        {
            result.setIssueTypeId(issueType.getIssueTypeId());
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public int getEnterIssueRedirect()
        throws TorqueException
    {
        if (enterIssueRedirect == 0)
        {
            UserPreference up = UserPreferenceManager.getInstance(getUserId());
            if (up != null && up.getEnterIssueRedirect() != 0)
            {
                enterIssueRedirect = up.getEnterIssueRedirect();
            }
        } 
        return enterIssueRedirect;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void setEnterIssueRedirect(int templateCode)
        throws TorqueException
    {
        UserPreference up = UserPreferenceManager.getInstance(getUserId());
        up.setEnterIssueRedirect(templateCode);
        up.save();
        enterIssueRedirect = templateCode;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public  String getDefaultQueryId(Module module) throws TorqueException
    {
        String homePage = getHomePage(module);
        String result;
        if(homePage.equals("IssueList.vm"))
        {
            Query q = QueryPeer.getDefaultQuery(module, this.getUserId());
            if(q != null)
            {
                homePage="IssueList.vm";
                long cnt = (q.getQueryId());
                return Long.toString(cnt);
            }
        }
        return "";
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
private boolean isHomePageValid(String homePage, Module module) throws TorqueException
    {
        boolean result = true;
        String perm = ScarabSecurity
            .getScreenPermission(homePage.replace(',','.'));
        if (perm != null && !hasPermission(perm, module)) 
        {
            result = false;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void setHomePage(final String homePage)
        throws TorqueException, ScarabException
    {
        if ("ModuleNotReady.vm".equals(homePage)) 
        {
            throw new ScarabException(L10NKeySet.ExceptionForbiddenHomeModuleNotReady);
        }
        final UserPreference up = UserPreferenceManager.getInstance(getUserId());
        up.setHomePage(homePage);
        up.save();
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getMITLists()
        throws TorqueException    
    {
        List result = null;

        Criteria crit = new Criteria();
        crit.add(MITListPeer.ACTIVE, true);
        Criteria.Criterion userCrit = crit.getNewCriterion(
            MITListPeer.USER_ID, getUserId(), Criteria.EQUAL);
        //userCrit.or(crit.getNewCriterion(
           // MITListPeer.USER_ID, null, Criteria.EQUAL));
        crit.add(userCrit);
        crit.add(MITListPeer.MODIFIABLE, true);
        crit.add(MITListPeer.ACTIVE, true);
        crit.add(MITListPeer.NAME, (Object)null, Criteria.NOT_EQUAL);
        crit.addAscendingOrderByColumn(MITListPeer.NAME);
        result = MITListPeer.doSelect(crit);

        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public boolean hasAnySearchableRMITs()
        throws TorqueException, DataSetException    
    {
        boolean result = false;
        final List moduleIds = getSearchableModuleIds();
        if (!moduleIds.isEmpty()) 
        {
            final Criteria crit = new Criteria();
            crit.addIn(RModuleIssueTypePeer.MODULE_ID, moduleIds);
            result = (RModuleIssueTypePeer.count(crit) > 0);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
private List getSearchableModuleIds()
        throws TorqueException    
    {
        Module[] userModules = getModules(ScarabSecurity.ISSUE__SEARCH);
        List moduleIds;
        if (userModules != null && (userModules.length > 1 ||
                userModules.length == 1 && !userModules[0].isGlobalModule())
           ) 
        {
            moduleIds = new ArrayList(userModules.length);
            for (int i=0; i<userModules.length; i++) 
            {
                Module module = userModules[i];
                if (!module.isGlobalModule()) 
                {
                    moduleIds.add(module.getModuleId()); 
                }                
            }
        }
        else 
        {
            moduleIds = Collections.EMPTY_LIST;
        }
        return moduleIds;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getUnusedRModuleIssueTypes(Module module)
        throws TorqueException
    {
        List result;
        if(module == null)
        {
            result = Collections.EMPTY_LIST;
        }
        else
        {
            Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, module.getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.PARENT_ID, 0)
                .add(IssueTypePeer.DELETED, false);
            addCurrentMITListExclusion(crit);
            result = RModuleIssueTypePeer.doSelect(crit);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getAllRModuleIssueTypes(Module module)
        throws TorqueException
    {
        List result;
        if(module == null)
        {
            result = Collections.EMPTY_LIST;
        }
        else
        {
            Criteria crit = new Criteria();
            crit.add(RModuleIssueTypePeer.MODULE_ID, module.getModuleId())
                .addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID, 
                         IssueTypePeer.ISSUE_TYPE_ID)
                .add(IssueTypePeer.PARENT_ID, 0)
                .add(IssueTypePeer.DELETED, false);
            result = RModuleIssueTypePeer.doSelect(crit);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
private void addCurrentMITListExclusion(Criteria crit)
        throws TorqueException    
    {
            // do not include RMIT's related to current MITListItems.
            MITList mitList = getCurrentMITList(getGenThreadKey());            
            if (mitList != null && mitList.getMITListItems() != null
                && !mitList.getMITListItems().isEmpty()) 
            {
                boolean addAnd = false;
                StringBuffer sb = new StringBuffer();
                Iterator mitItems = 
                    mitList.getExpandedMITListItems().iterator();
                while (mitItems.hasNext()) 
                {
                    MITListItem item = (MITListItem)mitItems.next();
                    if (mitList.getModule(item) != null 
                        && item.getIssueType() != null) 
                    {                  
                        if (addAnd) 
                        {
                            sb.append(" AND ");
                        }
                        
                        sb.append(" NOT (")
                            .append(RModuleIssueTypePeer.MODULE_ID)
                            .append('=')
                            .append(mitList.getModule(item).getModuleId())
                            .append(" AND ")
                            .append(RModuleIssueTypePeer.ISSUE_TYPE_ID)
                            .append('=')
                            .append(item.getIssueType().getIssueTypeId())
                            .append(')');
                        addAnd = true;
                    }
                }   
                // the column name used here is arbitrary (within limits)
                crit.add(IssueTypePeer.ISSUE_TYPE_ID, 
                         (Object)sb.toString(), Criteria.CUSTOM);
            }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public List getSearchableRMITs(String searchField, String searchString, 
                                   String sortColumn, String sortPolarity,
                                   Module skipModule)
        throws TorqueException    
    {
        List moduleIds = getSearchableModuleIds();
        if (skipModule != null) 
        {
            moduleIds.remove(skipModule.getModuleId());
        }
        
        List result;
        if (moduleIds.isEmpty()) 
        {
            result = Collections.EMPTY_LIST;
        }
        else 
        {
            Criteria crit = new Criteria();
            crit.addIn(RModuleIssueTypePeer.MODULE_ID, moduleIds);
            crit.addJoin(RModuleIssueTypePeer.ISSUE_TYPE_ID,
                         IssueTypePeer.ISSUE_TYPE_ID);
            crit.add(IssueTypePeer.PARENT_ID, 0);
            crit.add(IssueTypePeer.DELETED, false);
            addCurrentMITListExclusion(crit);

            // we could add the filter criteria here, but this might
            // result in full table scans.  Even if the table scan turns out
            // to be more efficient, I think it is better to move this
            // into the middle/front tier.
            //addFilterCriteria(crit, searchField, searchString);
            //addSortCriteria(crit, sortColumn, sortPolarity);
            
            result = RModuleIssueTypePeer.doSelect(crit);
            filterRMITList(result, searchField, searchString);
            sortRMITList(result, sortColumn, sortPolarity);
        }
        
        return result;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
protected void filterRMITList(List rmits, 
                                  String searchField, String searchString)
        throws TorqueException
    {
        String moduleName = null;
        String issueTypeName = null;
        if ("issuetype".equals(searchField)) 
        {
            issueTypeName = searchString;
        }
        else 
        {
            moduleName = searchString;
        }
        
        if (moduleName != null && moduleName.length() > 0)
        {
            for (int i=rmits.size()-1; i>=0; i--)
            {
                String name = ((RModuleIssueType)rmits.get(i))
                    .getModule().getRealName();
                if (name == null || name.indexOf(moduleName) == -1)
                {
                    rmits.remove(i);
                }
            }
        }
        if (issueTypeName != null && issueTypeName.length() > 0)
        {
            for (int i=rmits.size()-1; i>=0; i--)
            {
                String name = ((RModuleIssueType)rmits.get(i))
                    .getDisplayName();
                if (name == null || name.indexOf(issueTypeName) == -1)
                {
                    rmits.remove(i);
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void addRMITsToCurrentMITList(List rmits)
        throws TorqueException
    {
        if (rmits != null && !rmits.isEmpty()) 
        {
            MITList mitList = getCurrentMITList(getGenThreadKey());
            if (mitList == null) 
            {                
                mitList = MITListManager.getInstance();
                setCurrentMITList(mitList);
            }

            Iterator i = rmits.iterator();
            while (i.hasNext()) 
            {
                RModuleIssueType rmit = (RModuleIssueType)i.next();
                MITListItem item = MITListItemManager.getInstance();
                item.setModuleId(rmit.getModuleId());
                item.setIssueTypeId(rmit.getIssueTypeId());
                if (!mitList.contains(item)) 
                {
                    mitList.addMITListItem(item);        
                }
            }
        }
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public RModuleIssueType getCurrentRModuleIssueType()
        throws TorqueException
    {
        RModuleIssueType rmit = null;
        Module module = getCurrentModule();
        if (module != null) 
        {
            IssueType it = getCurrentIssueType();
            if (it != null) 
            {
                rmit = module.getRModuleIssueType(it);
            }
        }
        
        return rmit;
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void updateIssueListAttributes(List attributes)
        throws TorqueException
    {
        MITList mitList = getCurrentMITList();

        // Delete current attribute selections for user
        for (Iterator currentAttributes = mitList.getSavedRMUAs().iterator();
               currentAttributes.hasNext();) 
        {
            RModuleUserAttribute rmua = (RModuleUserAttribute)currentAttributes.next();
            Criteria crit = new Criteria();
            crit.add(RModuleUserAttributePeer.MODULE_ID, rmua.getModuleId());
            crit.add(RModuleUserAttributePeer.ISSUE_TYPE_ID, rmua.getIssueTypeId());
            crit.add(RModuleUserAttributePeer.USER_ID, rmua.getUserId());
            crit.add(RModuleUserAttributePeer.LIST_ID, rmua.getListId());
            crit.add(RModuleUserAttributePeer.INTERNAL_ATTRIBUTE, rmua.getInternalAttribute());
            RModuleUserAttributePeer.doDelete(crit);
        }

        int i = 1;
        for (Iterator iter = attributes.iterator(); iter.hasNext();) 
        {
            RModuleUserAttribute rmua = (RModuleUserAttribute)iter.next(); 
            rmua.setOrder(i++);
            rmua.setListId(mitList.getListId());
            if (mitList.isSingleIssueType())
            {
                rmua.setIssueType(mitList.getIssueType());
            }
            if (mitList.isSingleModule())
            {
                rmua.setModule(mitList.getModule());
            }
            rmua.save();
        }
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public void setTextFields(final ScarabUser user, 
            final Issue issue, 
            final Integer typeId) 
        throws TorqueException
    {
        setIssue(issue);
        setTypeId(typeId);
        setMimeType("text/plain");
        //setCreatedDate(new Date());
        setCreatedBy(user.getUserId());
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public void save(Connection dbCon)
        throws TorqueException
    {
        if (getIssue().isNew()) 
        {
            throw new TorqueException("Cannot save an attachment before saving"
                                      + " the issue to which it is attached."); //EXCEPTION
        }
        // It would be better (from an oo perspective) to do this whenever 
        // setData is called, but we can't be sure the typeId will be 
        // set prior to setting the url, so we will do the check here.
        setData(doMakeURLFromData());

        // need to handle the case where we don't want to be smart
        // and just set the dates to be whatever we want them
        // to be (xml import!).
        if (isNew() && (getCreatedDate() == null && getModifiedDate() == null))
        {
            Date now = new Date();
            setCreatedDate(now);
            setModifiedDate(now);
        }
        else if (isModified()) 
        {
            setModifiedDate(new Date());
        }
        
        super.save(dbCon);
        
        try
        {
            FileItem file = getFile();
            if (file != null) 
            {        
                File uploadFile = 
                    new File(getRepositoryDirectory(),getRelativePath());
                File parent = uploadFile.getParentFile();
                if (!parent.exists()) 
                {
                    mkdirs(parent);
                }                
                file.write(uploadFile);
            }
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public boolean deletePhysicalAttachment() 
	throws TorqueException, ScarabException
    {
        File f = new File(getFullPath());
        return f.delete();
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public String getRelativePath()
        throws TorqueException,ScarabException
    {
        if (isNew()) 
        {
            throw new ScarabException(L10NKeySet.ExceptionPathNotSet);
        }        
        String path = null;
        String filename = getFileName();
        if (filename != null) 
        {
            // moduleId/(issue_IdCount/1000)/issueID_attID_filename
            StringBuffer sb = new StringBuffer(30 + filename.length());
            final Issue issue = getIssue();
            sb.append("mod").append(issue.getModule().getQueryKey())
                .append(File.separator)
                .append(issue.getIdCount() / 1000)
                .append(File.separator)
                .append(issue.getUniqueId()).append('_')
                .append(getQueryKey()).append('_')
                .append(filename);
            path = sb.toString();
        }
        return path;
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public String getFullPath()
        throws TorqueException,ScarabException
    {
        String path = null;
        final String relativePath = getRelativePath();
        if (relativePath != null) 
        {
            path = getRepositoryDirectory() + File.separator + relativePath;
        }
        return path;
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public void copyFileTo(final String path)
        throws TorqueException, ScarabException, FileNotFoundException, IOException
    {
        copyFileFromTo(getFullPath(), path);
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public long getSize()
    	throws TorqueException, ScarabException
    {
        if (size== -1) {
        	Log.get(this.getClass().getName()).debug("getSize() reading attachment size from FileSystem");
	        final String path = getFullPath();
	        if (path != null) {
		        final File f = new File(getFullPath());
		        if (f!= null  && f.exists()) {
		            size = f.length();  
	            }
	        }
        } else {
        	Log.get(this.getClass().getName()).debug("getSize() reading attachment size from cache");
        }
        return size;
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public Attachment copy() throws TorqueException
    {
        Attachment copyObj = AttachmentManager.getInstance();
        copyObj.setIssueId(getIssueId());
        copyObj.setTypeId(getTypeId());
        copyObj.setName(getName());
        copyObj.setData(getData());
        copyObj.setFileName(getFileName());
        copyObj.setMimeType(getMimeType());
        copyObj.setModifiedBy(getModifiedBy());
        copyObj.setCreatedBy(getCreatedBy());
        copyObj.setModifiedDate(getModifiedDate());
        copyObj.setCreatedDate(getCreatedDate());
        copyObj.setDeleted(getDeleted());
        return copyObj;
    }
            
// in java/org/tigris/scarab/om/Attachment.java
public Activity getActivity() throws TorqueException
    {
        Activity activity = null;
        Criteria crit = new Criteria()
            .add(ActivityPeer.ATTACHMENT_ID, getAttachmentId());
        
        List activities = ActivityPeer.doSelect(crit);
        if (activities.size() > 0) 
        {
            activity = (Activity)activities.get(0);
        }
        return activity;
     }
            
// in java/org/tigris/scarab/om/ReportPeer.java
public static boolean exists(final String name)
        throws TorqueException, ScarabException
    {
        return retrieveByName(name) != null;
    }
            
// in java/org/tigris/scarab/om/ReportPeer.java
public static Report retrieveByName(final String name)
        throws TorqueException, ScarabException
    {
        Report report = null;
        final Criteria crit = new Criteria()
            .add(NAME, name)
            .add(DELETED, false);
        final List reports = doSelect(crit);
        if (reports.size() == 1) 
        {
            report = (Report)reports.get(0);
        }
        else if (reports.size() > 1) 
        {
            throw new ScarabException(L10NKeySet.ExceptionMultipleReports,
                                      name);
        }
        
        return report;
    }
            
// in java/org/tigris/scarab/om/ReportPeer.java
public static Report retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        Report result = null;
        Object obj = ScarabCache.get(REPORT_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseReportPeer.retrieveByPK(pk);
            ScarabCache.put(result, REPORT_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (Report)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/DependManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(DependPeer.DEPEND_ID);
        notifyListeners(listeners, oldOm, om);
        listeners = (List)listenersMap.get(DependPeer.OBSERVER_ID);
        notifyListeners(listeners, oldOm, om);
        listeners = (List)listenersMap.get(DependPeer.OBSERVED_ID);
        notifyListeners(listeners, oldOm, om);
        listeners = (List)listenersMap.get(DependPeer.DEPEND_TYPE_ID);
        notifyListeners(listeners, oldOm, om);
        listeners = (List)listenersMap.get(DependPeer.DELETED);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/RModuleOptionPeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)IssuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/AttributeType.java
public AttributeClass getAttributeClass()
        throws TorqueException
    {
        AttributeClass result = null;
        Object obj = ScarabCache.get(this, GET_ATTRIBUTE_CLASS);
        if (obj == null) 
        {
            result = super.getAttributeClass();
            ScarabCache.put(result, this, GET_ATTRIBUTE_CLASS);
        }
        else
        {
            result = (AttributeClass)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributeType.java
public static AttributeType getInstance(final String attributeTypeName) 
        throws TorqueException, ScarabException
    {
        AttributeType result = null;
        final Object obj = ScarabCache.get(ATTRIBUTETYPE, GET_INSTANCE, 
                                     attributeTypeName); 
        if (obj == null) 
        {        
            final Criteria crit = new Criteria();
            crit.add(AttributeTypePeer.ATTRIBUTE_TYPE_NAME, attributeTypeName);
            final List attributeTypes = AttributeTypePeer.doSelect(crit);
            if(attributeTypes.size() > 1)
            {
                throw new ScarabException(L10NKeySet.ExceptionDuplicateAttributeTypeName,
                                          attributeTypeName);
            }
            result = (AttributeType)attributeTypes.get(0);
            ScarabCache.put(result, ATTRIBUTETYPE, GET_INSTANCE, 
                            attributeTypeName);
        }
        else 
        {
            result = (AttributeType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/ScarabModulePeer.java
public static List getAllModules()
        throws TorqueException
    {
        return doSelect(new Criteria());
    }
            
// in java/org/tigris/scarab/om/Depend.java
public static Depend getInstance()
        throws TorqueException
    {
        return DependManager.getInstance();
    }
            
// in java/org/tigris/scarab/om/Depend.java
public Attachment getDescriptionAsAttachment(ScarabUser user, Issue issue)
        throws TorqueException
    {
        if (description == null || description.length() == 0)
        {
            return null;
        }
        Attachment comment = AttachmentManager.getInstance();
        comment.setTextFields(user, issue, Attachment.MODIFICATION__PK);
        comment.setData(getDescription());
        comment.setName("modification");
        comment.save();
        return comment;
    }
            
// in java/org/tigris/scarab/om/Depend.java
public void setDependType(String type)
        throws TorqueException
    {
        super.setDependType(DependTypeManager.getInstance(type));
    }
            
// in java/org/tigris/scarab/om/Depend.java
public void setObserverUniqueId(String uniqueId)
         throws TorqueException, ScarabException
    {
        if (getDefaultModule() == null)
        {
            throw new ScarabException( L10NKeySet.ExceptionDependInternalWorkflow,
                                       "setDefaultModule()",
                                       "setObserverUniqueId()");
        }
        Issue childIssue = IssueManager.getIssueById(uniqueId.trim());
        if (childIssue == null)
        {
           String code = getDefaultModule().getCode();
           uniqueId = code + uniqueId;
           childIssue = IssueManager.getIssueById(uniqueId);
        }
        super.setObserverId(childIssue.getIssueId());
    }
            
// in java/org/tigris/scarab/om/Depend.java
public void setProperties(Depend depend)
        throws TorqueException
    {
        this.setObservedId(depend.getObservedId());
        this.setObserverId(depend.getObserverId());
        this.setTypeId(depend.getTypeId());
    }
            
// in java/org/tigris/scarab/om/Depend.java
public void exchangeRoles() throws TorqueException
    {
        Long observerId = getObserverId();
        Long observedId = getObservedId();
        setObserverId(observedId);
        setObservedId(observerId);
    }
            
// in java/org/tigris/scarab/om/RAttributeAttributeGroup.java
public void delete() throws TorqueException 
    { 
        Criteria c = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, getGroupId())
            .add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID, getAttributeId());
            RAttributeAttributeGroupPeer.doDelete(c);
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public boolean canDelete(ScarabUser user)
        throws TorqueException
    {
        // can delete a template if they have delete permission
        // Or if is their personal template
        boolean hasPermission    = user.hasPermission(ScarabSecurity.ITEM__DELETE, getIssue().getModule());
        boolean isCreatedBySelf  = user.getUserId().equals(getIssue().getCreatedBy().getUserId());
        boolean hasScopePersonal = getScopeId().equals(Scope.PERSONAL__PK);
        return (hasPermission || (isCreatedBySelf && hasScopePersonal));
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public boolean canEdit(ScarabUser user)
        throws TorqueException
    {
        return canDelete(user);
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void saveAndSendEmail(final ScarabUser user, 
            final Module module, 
            final TemplateContext context)
        throws TorqueException, ScarabException
    {
        // If it's a module scoped template, user must have Item | Approve 
        //   permission, Or its Approved field gets set to false
        boolean success = true;
        final Issue issue = IssueManager.getInstance(getIssueId());

        // If it's a module template, user must have Item | Approve 
        //   permission, or its Approved field gets set to false
        if (getScopeId().equals(Scope.PERSONAL__PK)
            || user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
        } 
        else
        {
            setApproved(false);
            issue.save();

            // Send Email to the people with module edit ability so
            // that they can approve the new template
            if (context != null)
            {
                final String template = Turbine.getConfiguration().
                    getString("scarab.email.requireapproval.template",
                              "RequireApproval.vm");
                
                ScarabUser[] toUsers = module.getUsers(ScarabSecurity.MODULE__EDIT);
                // if the module doesn't have any users, then we need to add at 
                // least ourselves...
                if (toUsers.length == 0)
                {
                    toUsers = new ScarabUser[1];
                    toUsers[0] = user;
                }

                final EmailContext ectx = new EmailContext();
                ectx.setUser(user);
                ectx.setModule(module);
                ectx.setDefaultTextKey("NewTemplateRequiresApproval");

                final String fromUser = "scarab.email.default";
                try
                {
                    Email.sendEmail(ectx, 
                        module, 
                        fromUser,
                        module.getSystemEmail(),
                        Arrays.asList(toUsers),
                        null, template);
                }
                catch(Exception e)
                {
                    save();  // Not shure about this, but i think it's ok,
                             // because we already did an issue.save(), see above
                    throw new ScarabException(L10NKeySet.ExceptionGeneral,e); 
                }
            }
        }
        save();
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfo.java
public void approve(final ScarabUser user, final boolean approved)
         throws TorqueException, ScarabException
    {                
        final Module module = getIssue().getModule();

        if (user.hasPermission(ScarabSecurity.ITEM__APPROVE, module))
        {
            setApproved(true);
            if (!approved)
            {
                setScopeId(Scope.PERSONAL__PK);
            }
            save();
        } 
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }            
    }
            
// in java/org/tigris/scarab/om/RAttributeAttributeGroupManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(RAttributeAttributeGroupPeer.GROUP_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/RModuleIssueTypePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/DependTypeManager.java
public static DependType getInstance(String dependTypeName)
        throws TorqueException
    {
        DependType result = null;
        Object obj = ScarabCache.get(DEPENDTYPE, FIND_DEPENDTYPE_BY_NAME, 
                                     dependTypeName); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria();
            crit.add(DependTypePeer.DEPEND_TYPE_NAME, dependTypeName);
            List dependTypes = DependTypePeer.doSelect(crit);
            if (dependTypes == null || dependTypes.size() == 0)
            {
                throw new TorqueException("Invalid issue depend type: " + 
                                    dependTypeName); //EXCEPTION
            }
            result = (DependType)dependTypes.get(0);
            ScarabCache.put(result, DEPENDTYPE, FIND_DEPENDTYPE_BY_NAME, 
                            dependTypeName);
        }
        else 
        {
            result = (DependType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/DependTypeManager.java
public static DependType getInstanceById(String dependTypeId)
        throws TorqueException
    {
        DependType result = null;
        List dependTypes = getAll();
        for(int index=0; index < dependTypes.size(); index++)
        {
            DependType entry = (DependType)dependTypes.get(index);
            if(entry.getQueryKey().equals(dependTypeId))
            {
                result = entry;
                break;
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/DependTypeManager.java
public static List getAll()
        throws TorqueException
    {
        return getManager().getAllImpl();
    }
            
// in java/org/tigris/scarab/om/DependTypeManager.java
public List getAllImpl()
        throws TorqueException
    {
        List result = null;
        Object obj = getMethodResult().get(this.toString(), GET_ALL); 
        if (obj == null) 
        {        
            result = DependTypePeer.doSelect(new Criteria());
            getMethodResult().put(result, this.toString(), GET_ALL);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/DependTypeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        getMethodResult().remove(this, GET_ALL);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/DependTypeManager.java
public L10NKey getL10nKey( String dependTypeName ) 
        throws TorqueException 
    {
        return (L10NKey)l10nKeys.get( getInstance(dependTypeName).getDependTypeId());
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if (id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void delete(final ScarabUser user)
         throws TorqueException, ScarabException
    {                
        final Module module = getModule();
        final IssueType issueType = getIssueType();

        if (user.hasPermission(ScarabSecurity.MODULE__CONFIGURE, module))
        {
            // Delete both active and inactive attribute groups first
            final List attGroups = issueType.getAttributeGroups(module, false);
            for (int j=0; j<attGroups.size(); j++)
            {
                // delete attribute-attribute group map
                final AttributeGroup attGroup = 
                              (AttributeGroup)attGroups.get(j);
                attGroup.delete();
            }

            // Delete mappings with user attributes
            List rmas = module.getRModuleAttributes(issueType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
            // Delete mappings with user attributes for template type
            final IssueType templateType = issueType.getTemplateIssueType();
            rmas = module.getRModuleAttributes(templateType);
            for (int i=0; i<rmas.size(); i++)
            {
                ((RModuleAttribute)rmas.get(i)).delete();
            }
 
            // delete workflows
            WorkflowFactory.getInstance().resetAllWorkflowsForIssueType(module, 
                                                                        issueType);
            // delete templates
            Criteria c = new Criteria()
                .add(IssuePeer.TYPE_ID, templateType.getIssueTypeId());
            final List result = IssuePeer.doSelect(c);
            final List issueIdList = new ArrayList(result.size());
            for (int i=0; i < result.size(); i++) 
            {
                final Issue issue = (Issue)result.get(i);
                issueIdList.add(issue.getIssueId());
            }
            IssuePeer.doDelete(c);
            if (!issueIdList.isEmpty())
            {
                c = new Criteria()
                    .addIn(IssueTemplateInfoPeer.ISSUE_ID, issueIdList);
                IssueTemplateInfoPeer.doDelete(c);
            }
            
            // mit list items
            c = new Criteria()
                .add(MITListItemPeer.MODULE_ID, module.getModuleId())
                .add(MITListItemPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId());
            final List listItems = MITListItemPeer.doSelect(c);
            final List listIds = new ArrayList(listItems.size());

            for (int i=0; i < listItems.size(); i++) 
            {
                final MITList list = ((MITListItem)listItems.get(i)).getMITList();
                final Long listId = list.getListId();
                if (list.isSingleModuleIssueType() && !listIds.contains(listId))
                {
                    listIds.add(listId);
                }
            }
            MITListItemPeer.doDelete(c);

            if (!listIds.isEmpty())
            {
                // delete single module-issuetype mit lists
                c = new Criteria()
                    .addIn(MITListPeer.LIST_ID, listIds);
                MITListPeer.doDelete(c);

                // delete queries
                c = new Criteria()
                    .addIn(QueryPeer.LIST_ID, listIds);
                QueryPeer.doDelete(c);
            }

            c = new Criteria()
                .add(RModuleIssueTypePeer.MODULE_ID, getModuleId())
                .add(RModuleIssueTypePeer.ISSUE_TYPE_ID, getIssueTypeId());
            RModuleIssueTypePeer.doDelete(c);
            RModuleIssueTypeManager.removeFromCache(this);
            final List rmits = module.getRModuleIssueTypes();
            rmits.remove(this);
        }
        else
        {
            throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
        }
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public RModuleIssueType copy()
         throws TorqueException
    {
        RModuleIssueType rmit2 = new RModuleIssueType();
        rmit2.setModuleId(getModuleId());
        rmit2.setIssueTypeId(getIssueTypeId());
        rmit2.setActive(getActive());
        rmit2.setDisplay(getDisplay());
        rmit2.setDisplayDescription(getDisplayDescription());
        rmit2.setOrder(getOrder());
        rmit2.setDedupe(getDedupe());
        rmit2.setHistory(getHistory());
        rmit2.setComments(getComments());
        return rmit2;
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public List<Condition> getConditions(Criteria criteria) throws TorqueException
    {
    	criteria.add(ConditionPeer.ATTRIBUTE_ID, (Object)(ConditionPeer.ATTRIBUTE_ID + " IS NULL"), Criteria.CUSTOM);
    	return super.getConditions(criteria);
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void setConditionsArray(Integer[] aOptionId, Integer operator) throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(ConditionPeer.ATTRIBUTE_ID, null);
        crit.add(ConditionPeer.MODULE_ID, this.getModuleId());
        crit.add(ConditionPeer.ISSUE_TYPE_ID, this.getIssueTypeId());
        crit.add(ConditionPeer.TRANSITION_ID, null);
        ConditionPeer.doDelete(crit);
        this.save();
        this.getConditions().clear();
        ConditionManager.clear();
        if (aOptionId != null)
            for (int i = 0; i < aOptionId.length; i++)
            {
                if (aOptionId[i].intValue() != 0)
                {
                    Condition cond = new Condition();
                    cond.setAttributeId(null);
                    cond.setOptionId(aOptionId[i]);
                    cond.setModuleId(this.getModuleId());
                    cond.setIssueTypeId(this.getIssueTypeId());
                    cond.setTransitionId(null);
                    cond.setOperator(operator);
                    this.addCondition(cond);
                    cond.save();
                }
            }
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public boolean isRequiredIf(Integer optionID) throws TorqueException
    {
        Condition cond = new Condition();
        cond.setAttributeId(null);
        cond.setOptionId(optionID);
        cond.setModuleId(this.getModuleId());
        cond.setIssueTypeId(this.getIssueTypeId());
        cond.setTransitionId(null);
        return this.getConditions().contains(cond);

    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void addCondition(Condition cond) throws TorqueException
    {
        getConditions().add(cond);
        cond.setRModuleIssueType(this);
    }
            
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap
            .get(RModuleIssueTypePeer.MODULE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
public static void removeFromCache(RModuleIssueType module)
        throws TorqueException
    {
        ObjectKey key = module.getPrimaryKey();
        getManager().removeInstanceImpl(key);
    }
            
// in java/org/tigris/scarab/om/RModuleIssueTypeManager.java
public static RModuleIssueType getInstance(String key)
        throws TorqueException
    {
        if (key == null) 
        {
            throw new NullPointerException(
                "Cannot request a RModuleIssueType using a null key."); //EXCEPTION
        }
        int colonPos = key.indexOf(':');
        if (colonPos == -1) 
        {
            throw new IllegalArgumentException(
                "RModuleIssueType keys must be of the form N1:N2, not " + key); //EXCEPTION
        }
        // { module_id, issue_type_id } 
        SimpleKey[] keyArray = { new NumberKey(key.substring(1, colonPos)), 
            new NumberKey(key.substring(colonPos+2, key.length()-1)) 
            };
        return getInstance(new ComboKey(keyArray));
    }
            
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes(String attributeType, boolean includeDeleted,
                                     String sortColumn, String sortPolarity)
        throws TorqueException
    {
        Serializable[] cacheKey = {ATTRIBUTE_PEER, GET_ATTRIBUTES, attributeType, Boolean.valueOf(includeDeleted), 
                               sortColumn, sortPolarity};
        List attributes = (List)AttributeManager.getMethodResult().get(cacheKey);
        if(attributes==null)
        {
            Criteria crit = new Criteria();
            crit.add(AttributePeer.ATTRIBUTE_ID, 0, Criteria.NOT_EQUAL);
            if (!includeDeleted)
            {
                crit.add(AttributePeer.DELETED, 0);
            }
            if (attributeType.equals("user"))
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY);
            }
            else
            {
                crit.add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                         AttributeTypePeer.USER_TYPE_KEY, Criteria.NOT_EQUAL);
            }
            if (sortColumn.equals("desc"))
            {
                addSortOrder(crit, AttributePeer.DESCRIPTION, 
                             sortPolarity);
            }
            else if (sortColumn.equals("date"))
            {
                addSortOrder(crit, AttributePeer.CREATED_DATE, 
                             sortPolarity);
            }
            else if (sortColumn.equals("type"))
            {
                crit.addJoin(AttributePeer.ATTRIBUTE_TYPE_ID, 
                             AttributeTypePeer.ATTRIBUTE_TYPE_ID);
                addSortOrder(crit, AttributeTypePeer .ATTRIBUTE_TYPE_NAME, 
                             sortPolarity);
            }
            else if (!sortColumn.equals("user"))
            {
                addSortOrder(crit, AttributePeer.ATTRIBUTE_NAME, 
                             sortPolarity);
            }
            
            attributes = doSelect(crit);

            if (sortColumn.equals("user"))
            {
                attributes = sortAttributesByCreatingUser(attributes, sortPolarity);
            }
            
            AttributeManager.getMethodResult().put(attributes, cacheKey);
        }
        return attributes;
    }
            
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getFilteredAttributes(String name, String description,
                                             String searchField)
        throws TorqueException
    {
        List result = null;
        List allAttributes = getAttributes();
        if (allAttributes == null || allAttributes.size() == 0) 
        {
            result = Collections.EMPTY_LIST;
        }
        else 
        {
            List attrIds = new ArrayList();
            for (int i = 0; i < allAttributes.size(); i++)
            {
                attrIds.add(((Attribute)allAttributes.get(i)).getAttributeId());
            }
            Criteria crit = new Criteria();
            crit.addIn(AttributePeer.ATTRIBUTE_ID, attrIds);
            Criteria.Criterion c = null;
            Criteria.Criterion c1 = null;
            Criteria.Criterion c2 = null;
            
            if (name != null)
            {
                c1 = crit.getNewCriterion(AttributePeer.ATTRIBUTE_NAME,
                         addWildcards(name), Criteria.LIKE);
            }
            if (description != null)
            { 
                c2 = crit.getNewCriterion(AttributePeer.DESCRIPTION,
                         addWildcards(description), Criteria.LIKE);
            }
            if (searchField.equals("Name"))
            {
                c = c1;
            } 
            else if (searchField.equals("Description"))
            {
                c = c2;
            }
            else if (searchField.equals("Any"))
            {
                c = c1.or(c2);
            }
            crit.and(c);
            result = AttributePeer.doSelect(crit);
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes()
        throws TorqueException
    {
        return getAttributes(NON_USER, false, AttributePeer.ATTRIBUTE_NAME, "asc");
    }
            
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes(String attributeType)
        throws TorqueException
    {
        return getAttributes(attributeType, false, AttributePeer.ATTRIBUTE_NAME, 
                             "asc");
    }
            
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes(String attributeType, boolean includeDeleted)
        throws TorqueException
    {
        return getAttributes(attributeType, includeDeleted, AttributePeer.ATTRIBUTE_NAME, 
                             "asc");
    }
            
// in java/org/tigris/scarab/om/AttributePeer.java
public static List getAttributes(String sortColumn, 
                                     String sortPolarity)
        throws TorqueException
    {
        return getAttributes(NON_USER, false, sortColumn, sortPolarity);
    }
            
// in java/org/tigris/scarab/om/AttributePeer.java
private static List sortAttributesByCreatingUser(List result,
                                                     String sortPolarity)
        throws TorqueException
    {
        final int polarity = ("asc".equals(sortPolarity)) ? 1 : -1;   
        Comparator c = new Comparator() 
        {
            public int compare(Object o1, Object o2) 
            {
                int i = 0;
                try
                {
                    i = polarity * 
                        ((Attribute)o1).getCreatedUserName()
                         .compareTo(((Attribute)o2).getCreatedUserName());
                }
                catch (Exception e)
                {
                    //
                }
                return i;
             }
        };
        Collections.sort(result, c);
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributeManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttributePeer.ATTRIBUTE_ID);
        notifyListeners(listeners, oldOm, om);
        getMethodResult().removeAll(AttributePeer.ATTRIBUTE_PEER, AttributePeer.GET_ATTRIBUTES);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static int count(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT);
        return ((Record)AttributeValuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static int countDistinct(Criteria crit)
        throws TorqueException, DataSetException
    {
        crit.addSelectColumn(COUNT_DISTINCT);
        return ((Record)AttributeValuePeer.doSelectVillageRecords(crit).get(0))
            .getValue(1).asInt();
    }
            
// in java/org/tigris/scarab/om/AttributeValuePeer.java
public static Class getOMClass(Record record, int offset) 
        throws TorqueException
    {
        Class c = null;
        try
        {
            Integer attId = new Integer(record.getValue(offset-1 + 3)
                                            .asString());
            Attribute attribute = AttributeManager.getInstance(attId);
            String className = attribute.getAttributeType().getJavaClassName();

            c = (Class)classMap.get(className);
            if (c == null) 
            {
                c = Class.forName(className);
                classMap.put(className, c);            
            }
        }
        catch (Exception e)
        {
            throw new TorqueException(e); //EXCEPTION
        }
        
        return c;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean isGlobal()
        throws TorqueException
    {
        return (getModule() == null);
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void setModule(Module me)
        throws TorqueException
    {
        Integer id = me.getModuleId();
        if ( id == null) 
        {
            throw new TorqueException("Modules must be saved prior to " +
                                      "being associated with other objects."); //EXCEPTION
        }
        setModuleId(id);
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public Module getModule()
        throws TorqueException
    {
        Module module = null;
        Integer id = getModuleId();
        if ( id != null ) 
        {
            module = ModuleManager.getInstance(id);
        }
        
        return module;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean hasAnyOptionAttributes()
        throws TorqueException
    {
        boolean result = false;
        for (Iterator i = getAttributes().iterator(); i.hasNext() && !result;) 
        {
            result = ((Attribute)i.next()).isOptionAttribute();
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public List getAttributes()
        throws TorqueException
    {
        List result = null;
        Object obj = getMethodResult().get(this, GET_ATTRIBUTES); 
        if (obj == null) 
        {        
            Log.get().debug("getAttributes() not cached, getting from db");
            Criteria crit = new Criteria()
                .add(RAttributeAttributeGroupPeer.GROUP_ID, 
                     getAttributeGroupId())
                .addJoin(RAttributeAttributeGroupPeer.ATTRIBUTE_ID, 
                         AttributePeer.ATTRIBUTE_ID)
                .add(AttributePeer.ATTRIBUTE_TYPE_ID, 
                     AttributeTypePeer.USER_TYPE_KEY, Criteria.NOT_EQUAL)
                .add(AttributePeer.DELETED, false)
                .addAscendingOrderByColumn(RAttributeAttributeGroupPeer
                                           .PREFERRED_ORDER);
            List raags = RAttributeAttributeGroupPeer.doSelect(crit);
            result = new LinkedList();
            Iterator i = raags.iterator();
            while (i.hasNext()) 
            {
                Integer id = ((RAttributeAttributeGroup)i.next())
                    .getAttributeId();
                result.add(AttributeManager.getInstance(SimpleKey.keyFor(id)));
                if (Log.get().isDebugEnabled()) 
                {
                    Log.get().debug("attribute id=" + id + 
                                    "'s relationship to group was in db");
                }
            }
            getMethodResult().put(result, this, GET_ATTRIBUTES);
        }
        else 
        {
            result = (List)obj;
            if (Log.get().isDebugEnabled()) 
            {
                Log.get().debug("getAttributes() returning cached value");
                for (Iterator i = result.iterator(); i.hasNext();) 
                {
                    Log.get().debug("attribute id=" + 
                                    ((Attribute)i.next()).getAttributeId() + 
                                    "'s relationship to group was in cache");
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean hasAttribute(Attribute attribute)
        throws TorqueException
    {
        List raags = getAttributes();
        return (raags != null && raags.contains(attribute));
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public int getHighestOrderedAttribute ()
        throws TorqueException
    {
        int highest = 0;
        Criteria crit = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, 
                 getAttributeGroupId())
            .addAscendingOrderByColumn(RAttributeAttributeGroupPeer
                                       .PREFERRED_ORDER);
        List raags = RAttributeAttributeGroupPeer.doSelect(crit);
        if (raags.size() > 0)
        {
            RAttributeAttributeGroup raag = (RAttributeAttributeGroup)
                                             raags.get(raags.size()-1);
            highest = raag.getOrder();
        }
        return highest + 1;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public RAttributeAttributeGroup getRAttributeAttributeGroup
        (Attribute attribute)
        throws TorqueException
    {
        RAttributeAttributeGroup result = null;
        Object obj = ScarabCache.get(this, GET_R_ATTRIBUTE_ATTRGROUP, 
                                     attribute); 
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(RAttributeAttributeGroupPeer.GROUP_ID, 
                     getAttributeGroupId())
                .add(RAttributeAttributeGroupPeer.ATTRIBUTE_ID, 
                     attribute.getAttributeId());
           
            List resultList = RAttributeAttributeGroupPeer.doSelect(crit);
            if(resultList != null && resultList.size() > 0)
            {
                result = (RAttributeAttributeGroup)resultList.get(0);
                ScarabCache.put(result, this, GET_R_ATTRIBUTE_ATTRGROUP, 
                                attribute);
            }
            else
            {
                result = null;
            }
        }
        else 
        {
            result = (RAttributeAttributeGroup)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public List getRModuleAttributes()
        throws TorqueException
    {
        List attrs = getAttributes();
        Iterator i = attrs.iterator();
        List rmas = new ArrayList(attrs.size());
        while (i.hasNext()) 
        {
            Attribute attr = (Attribute)i.next();
            RModuleAttribute rma = getModule().getRModuleAttribute(attr, getIssueType());
            if (rma != null)
            {
                rmas.add(rma);
            }
        }
        return rmas;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public List getRIssueTypeAttributes()
        throws TorqueException
    {
        List attrs = getAttributes();
        Iterator i = attrs.iterator();
        List rias = new ArrayList(attrs.size());
        while (i.hasNext()) 
        {
            Attribute attr = (Attribute)i.next();
            RIssueTypeAttribute ria =
                getIssueType().getRIssueTypeAttribute(attr);
            
            if (ria != null)
            {
                rias.add(ria);
            }
        }
        
        return rias;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void delete()
         throws TorqueException, ScarabException
    {                
        int dupeSequence = 0;
        final Integer issueTypeId = getIssueTypeId();
        final IssueType issueType = IssueTypeManager
            .getInstance(SimpleKey.keyFor(issueTypeId), false);
        List attrGroups = null;

        if (isGlobal())
        {
            attrGroups = issueType.getAttributeGroups(null, false);
            dupeSequence =  issueType.getDedupeSequence();
            // Delete issuetype-attribute mapping
            final Criteria crit  = new Criteria()
                .addJoin(RIssueTypeAttributePeer.ATTRIBUTE_ID,
                         RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                .add(RAttributeAttributeGroupPeer.GROUP_ID,
                     getAttributeGroupId())
                .add(RIssueTypeAttributePeer.ISSUE_TYPE_ID, issueTypeId);
            final List results = RIssueTypeAttributePeer.doSelect(crit);
            for (Iterator i = results.iterator(); i.hasNext();)
            {
                ((RIssueTypeAttribute)i.next()).delete();
            }
        }
        else
        {
            if (issueType.getLocked())
            { 
                
                throw new ScarabException(L10NKeySet.ExceptionGroupDeleteForbidden,
                          this.getName(),
                          issueType.getName());
            }            
            else
            {
                final Module module = getModule();
                attrGroups = getIssueType().getAttributeGroups(module, false);
                dupeSequence =  module.getDedupeSequence(issueType);
                // Delete module-attribute mapping
                final Criteria crit  = new Criteria()
                    .addJoin(RModuleAttributePeer.ATTRIBUTE_ID,
                             RAttributeAttributeGroupPeer.ATTRIBUTE_ID)
                    .add(RAttributeAttributeGroupPeer.GROUP_ID,
                             getAttributeGroupId())
                    .add(RModuleAttributePeer.MODULE_ID,
                         getModuleId());
                final Criteria.Criterion critIssueType = crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                getIssueTypeId(), Criteria.EQUAL);
                critIssueType.or(crit.getNewCriterion(
                RModuleAttributePeer.ISSUE_TYPE_ID,
                issueType.getTemplateId(), Criteria.EQUAL));
                crit.and(critIssueType);
                final List results = RModuleAttributePeer.doSelect(crit);
                for (int i=0; i<results.size(); i++)
                {
                    final RModuleAttribute rma = (RModuleAttribute)results.get(i);
                    rma.delete();
                }
            }
        }

        // Delete attribute - attribute group mapping
        Criteria crit2 = new Criteria()
            .add(RAttributeAttributeGroupPeer.GROUP_ID, getAttributeGroupId());
        RAttributeAttributeGroupPeer.doDelete(crit2);


        // Delete the attribute group
        final int order = getOrder();
        crit2 = new Criteria()
            .add(AttributeGroupPeer.ATTRIBUTE_GROUP_ID, getAttributeGroupId());
        AttributeGroupPeer.doDelete(crit2);
        IssueTypeManager.getManager().refreshedObject(this);
            
        // Adjust the orders for the other attribute groups
        for (int i=0; i<attrGroups.size(); i++)
        {
            final AttributeGroup tempGroup = (AttributeGroup)attrGroups.get(i);
            int tempOrder = tempGroup.getOrder();
            if (tempGroup.getOrder() > order)
            {
                if (tempOrder == dupeSequence + 1 && tempOrder == 3)
                {
                    tempGroup.setOrder(tempOrder - 2);
                }
                else
                {
                    tempGroup.setOrder(tempOrder - 1);
                }
                tempGroup.save();
            }
        } 
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void addAttribute(final Attribute attribute)
         throws TorqueException, ScarabException
    {                
        final IssueType issueType = getIssueType();
        final Module module = getModule();

        // add attribute group-attribute mapping
        final RAttributeAttributeGroup raag =
            addRAttributeAttributeGroup(attribute);
        raag.save();
        if (Log.get().isDebugEnabled()) 
        {
            Log.get().debug("Calling getAttributes() from addAttribute in order to add attribute id="
                            + attribute.getAttributeId() + " to the List");
        }
        // FIXME! Distributed cache buster, cache should be invalidated.
        final List attributes = getAttributes();
        if (!attributes.contains(attribute)) 
        {
            attributes.add(attribute);
        }
        
        final List allOptions = attribute.getAttributeOptions(false);
        // remove duplicate options
        // FIXME! why would we ever want Attribute.getAttributeOptions to
        // return dupes, should this code be in that method?
        final ArrayList options = new ArrayList();
        for (int i=0; i<allOptions.size(); i++)
        {
            final AttributeOption option = (AttributeOption)allOptions.get(i);
            if (!options.contains(option))
            {
                options.add(option);
            }
        }

        if (isGlobal())
        {
            // this is a global attribute group
            // add issuetype-attribute groupings
            issueType.addRIssueTypeAttribute(attribute);

            // add issueType-attributeoption mappings
            for (int j=0;j < options.size();j++)
            {
                final AttributeOption option = (AttributeOption)options.get(j);
                final List roos = option.getROptionOptionsRelatedByOption2Id();
                final ROptionOption roo = (ROptionOption)roos.get(0);
                final RIssueTypeOption rio = new RIssueTypeOption();
                rio.setIssueTypeId(issueType.getIssueTypeId());
                rio.setOptionId(option.getOptionId());
                rio.setOrder(roo.getPreferredOrder());
                rio.setWeight(roo.getWeight());
                // making sure error is recorded in same log as our other
                // debugging for pcn 17683.
                try 
                {
                    rio.save();                    
                }
                catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
            }
        }
        else
        {
            // add module-attribute groupings
            module.addRModuleAttribute(issueType, attribute);

            // add module-attributeoption mappings
            for (int j=0;j < options.size();j++)
            {
                final AttributeOption option = (AttributeOption)options.get(j);
                final List roos = option.getROptionOptionsRelatedByOption2Id();
                final ROptionOption roo = (ROptionOption)roos.get(0);
                final RModuleOption rmo = new RModuleOption();
                rmo.setModuleId(getModuleId());
                rmo.setIssueTypeId(issueType.getIssueTypeId());
                rmo.setOptionId(option.getOptionId());
                rmo.setDisplayValue(option.getName());
                rmo.setOrder(roo.getPreferredOrder());
                rmo.setWeight(roo.getWeight());
                rmo.save();

                // add module-attributeoption mappings to template type
                final IssueType templateType = IssueTypeManager
                    .getInstance(issueType.getTemplateId(), false);
                final RModuleOption rmo2 = module.
                     addRModuleOption(templateType, option);
                rmo2.save();
            }
        }
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void deleteAttribute(final Attribute attribute, 
            final ScarabUser user,
            final Module module)
         throws TorqueException, ScarabException
    {                
        String permission = null;
        if (isGlobal())
        {
            permission = (ScarabSecurity.DOMAIN__EDIT);
        }
        else
        {
            permission = (ScarabSecurity.MODULE__CONFIGURE);
        }
        if (user.hasPermission(permission, module))
        {
            final IssueType issueType = getIssueType();
            final IssueType template = IssueTypeManager.getInstance
                                 (issueType.getTemplateId());
            boolean success = true;

            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attribute);
            if (isGlobal())
            {
                // This is a global attribute group
                // Remove attribute - issue type mapping
                final List rias = issueType.getRIssueTypeAttributes
                                     (false, AttributePeer.NON_USER);
                if (ria != null) 
                {
                    ria.delete();                    
                }
                if (rias != null) 
                {
                    rias.remove(ria);        
                }
            }
            else
            {
                // Check if attribute is locked
                if (ria != null && ria.getLocked())
                {
                    success = false;
                    throw new TorqueException(attribute.getName() + "is locked"); //EXCEPTION
                }
                else
                {
                    // Remove attribute - module mapping
                    final List rmas = module.getRModuleAttributes(issueType, false,
                                                            AttributePeer.NON_USER);    
                    final RModuleAttribute rma = module
                        .getRModuleAttribute(attribute, issueType);
                    if(rma != null)rma.delete();
                    WorkflowFactory.getInstance().deleteWorkflowsForAttribute
                                                  (attribute, module, issueType);
                    if(rma != null)rmas.remove(rma);

                    // Remove attribute - module mapping from template type
                    final RModuleAttribute rma2 = module
                                   .getRModuleAttribute(attribute, template);
                    if(rma2 != null)
                    {
                        rma2.delete();
                        rmas.remove(rma2);
                    }
                }
            }

            if (success)
            {
                // Remove attribute - group mapping
                final RAttributeAttributeGroup raag = 
                    getRAttributeAttributeGroup(attribute);
                raag.delete();

                if (attribute.isOptionAttribute())
                {
                    if (isGlobal())
                    { 
                        // global attributeGroup; remove issuetype-option maps
                        final List rios = issueType.getRIssueTypeOptions(attribute);
                        if (rios != null)
                        {
                            for (int i = 0; i<rios.size();i++)
                            {
                                ((RIssueTypeOption) rios.get(i))
                                    .delete(user, module);
                            }
                        }
                    }
                    else
                    {
                        // Remove module-option mapping
                        final List rmos = module.getRModuleOptions(attribute, issueType);
                        if (rmos != null)
                        {
                            rmos.addAll(module.getRModuleOptions(attribute, template));
                            for (int j = 0; j<rmos.size();j++)
                            {
                                final RModuleOption rmo = (RModuleOption)rmos.get(j);
                                 // rmo's may be inherited by the parent module.
                                 // don't delete unless they are directly associated
                                 // with this module.  Will know by the first one.
                                 if (rmo.getModuleId().equals(module.getModuleId())) 
                                 {
                                     rmo.delete();
                                 }
                                 else 
                                 {
                                     break;
                                 } 
                             }
                         }
                     }
                 }
             }
         }
         else
         {
             throw new ScarabException(L10NKeySet.YouDoNotHavePermissionToAction);
         }            
        getMethodResult().remove(this, AttributeGroup.GET_ATTRIBUTES);
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
private RAttributeAttributeGroup addRAttributeAttributeGroup(Attribute attribute)
         throws TorqueException
    {                
        RAttributeAttributeGroup raag = new RAttributeAttributeGroup();
        raag.setGroupId(getAttributeGroupId());
        raag.setAttributeId(attribute.getAttributeId());
        if (Log.get().isDebugEnabled()) 
        {
            Log.get().debug("Calling getAttributes() from addRAttributeAttributeGroup "
                            + "in order to determine order for attribute id=" + 
                            attribute.getAttributeId());
        }
        raag.setOrder(getAttributes().size() +1);
        return raag;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public AttributeGroup copyGroup()
         throws TorqueException
    {                
        AttributeGroup newGroup = new AttributeGroup();
        newGroup.setName(getName());
        newGroup.setDescription(getDescription());
        newGroup.setDedupe(getDedupe());
        newGroup.setActive(getActive());
        newGroup.setOrder(getOrder());
        return newGroup;
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public boolean isVisible4User(ScarabUser user) throws TorqueException
    {
        Role role = this.getRole4View();
        boolean bRdo = false;
        if (role == null)
        {
            bRdo = true;
        }
        else
        {
            if (user != null)
            {
                try
                {
	            AccessControlList acl = TurbineSecurity.getACL(user);
	            GroupSet allGroups = TurbineSecurity.getAllGroups();
                    Group group = allGroups.getGroup(user.getCurrentModule().getName());
                    bRdo = acl.hasRole(role, group);
                }
                catch(org.apache.fulcrum.security.util.DataBackendException dbe)
                {
                    throw new TorqueException("failed to get user's groups", dbe);
                }
                catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
            }
        }
        return bRdo;	
    }
            
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getQueries(Module module, IssueType issueType,
                                  ScarabUser user, String sortColumn,   
                                  String sortPolarity, String type)
        throws TorqueException
    {
        List queries = null;
        if (module == null || module.isGlobalModule())
        {
            queries = new ArrayList();
        }
        else 
        {
            Serializable[] key = {QUERY_PEER, GET_QUERIES, module, 
                issueType, user, sortColumn, sortPolarity, type};
            Object obj = QueryManager.getMethodResult().get(key);
            if (obj == null) 
            {

                Criteria crit = new Criteria()
                .add(QueryPeer.DELETED, 0);

                Criteria.Criterion moduleCrit = crit.getNewCriterion(
                        QueryPeer.MODULE_ID, module.getModuleId(), Criteria.EQUAL);
                Criteria.Criterion crossModule = crit.getNewCriterion(
                        QueryPeer.MODULE_ID, null, Criteria.EQUAL);
                moduleCrit.or(crossModule);

                if (issueType != null) 
            {
                Criteria.Criterion issueTypeCrit = crit.getNewCriterion(
                    QueryPeer.ISSUE_TYPE_ID, issueType.getIssueTypeId(), 
                    Criteria.EQUAL);
                Criteria.Criterion nullIssueTypeCrit = crit.getNewCriterion(
                    QueryPeer.ISSUE_TYPE_ID, null, Criteria.EQUAL);
                moduleCrit.and(issueTypeCrit.or(nullIssueTypeCrit));
            }
            



            
            if (TYPE_PRIVATE.equals(type))
            {
                crit.add(userPrivateQueriesCrits(user, crit, moduleCrit));                    
            }
            else if (TYPE_GLOBAL.equals(type))
            {
                crit.add(allGlobalQueriesCrit(crit, moduleCrit));
            }
            else if (TYPE_ALL_USER.equals(type))
            {
                Criteria.Criterion cuGlob = userUnapprovedQueriesCrits(user, crit, moduleCrit);
                Criteria.Criterion cPriv  = userPrivateQueriesCrits(user, crit, moduleCrit);
                cuGlob.or(cPriv);

                Integer moduleOwnerId = module.getOwnerId();
                Integer userId        = user.getUserId();
                if (moduleOwnerId.equals(userId))
                {
                    Criteria.Criterion owner  = ownerQueriesCrit(moduleOwnerId, crit, moduleCrit);
                    cuGlob.or(owner);                    
                }        
                crit.add(cuGlob);
            }
            else
            {
                // All queries
                Criteria.Criterion cGlob  = allGlobalQueriesCrit(crit, moduleCrit);
                Criteria.Criterion cPriv  = userPrivateQueriesCrits(user, crit, moduleCrit);
                cGlob.or(cPriv);
                crit.add(cGlob);
            }

            // Add sort criteria
            if (SORT_DESCRIPTION.equals(sortColumn))
            {
                addSortOrder(crit, QueryPeer.DESCRIPTION, 
                             sortPolarity);
            }
            else if (SORT_AVAILABILITY.equals(sortColumn))
            {
                crit.addJoin(QueryPeer.SCOPE_ID,
                             ScopePeer.SCOPE_ID);
                addSortOrder(crit, ScopePeer.SCOPE_NAME, sortPolarity);
            }
            else if (SORT_USER.equals(sortColumn))
            {
                addSortOrder(crit, QueryPeer.USER_ID, sortPolarity);
            }
            else
            {
                // sort by name
                addSortOrder(crit, QueryPeer.NAME, sortPolarity);
            }
            String tmp = crit.toString();
            queries = QueryPeer.doSelect(crit);
            QueryManager.getMethodResult().put(queries, key);
        }
        else 
        {
            queries = (List)obj;
        }
        }
        return queries;
    }
            
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getUserQueries(ScarabUser user)
        throws TorqueException
    {
        List queries = null;
        Object obj = QueryManager.getMethodResult()
            .get(QUERY_PEER, GET_USER_QUERIES, user);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
                .add(QueryPeer.DELETED, 0);
            crit.add(QueryPeer.USER_ID, user.getUserId());
            queries = QueryPeer.doSelect(crit);
            QueryManager.getMethodResult()
                .put(queries, QUERY_PEER, GET_USER_QUERIES, user);
        }
        else 
        {
            queries = (List)obj;
        }
        return queries;
    }
            
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getModuleQueries(Module module)
        throws TorqueException
    {
        List queries = null;
        Object obj = QueryManager.getMethodResult()
            .get(QUERY_PEER, GET_MODULE_QUERIES, module);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
                .add(QueryPeer.DELETED, 0);
            crit.add(QueryPeer.MODULE_ID, module.getModuleId());
            crit.add(QueryPeer.SCOPE_ID, Scope.MODULE__PK);
            queries = QueryPeer.doSelect(crit);
            QueryManager.getMethodResult()
                .put(queries, QUERY_PEER, GET_MODULE_QUERIES, module);
         }
        else 
        {
            queries = (List)obj;
        }
        return queries;
    }
            
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getQueries(Module module, IssueType issueType,
                                     ScarabUser user)
        throws TorqueException
    {
        return getQueries(module, issueType, user, SORT_AVAILABILITY, "asc", 
                          TYPE_ALL);
    }
            
// in java/org/tigris/scarab/om/QueryPeer.java
public static List getQueries(Module module, IssueType issueType,
                                     ScarabUser user, String sortColumn,   
                                     String sortPolarity)
        throws TorqueException
    {
        return getQueries(module, issueType, user, sortColumn, 
                          sortPolarity, TYPE_ALL);
    }
            
// in java/org/tigris/scarab/om/QueryPeer.java
public static Query getDefaultQuery(Module module) throws TorqueException 
    {
        Integer moduleOwnerId = module.getOwnerId();
        return getDefaultQuery(module, moduleOwnerId);
    }
            
// in java/org/tigris/scarab/om/QueryPeer.java
public static Query getDefaultQuery(Module module, Integer userId) throws TorqueException 
    {
        List<Query> queries = null;
        Object obj = QueryManager.getMethodResult()
            .get(QUERY_PEER, GET_MODULE_QUERIES, module, "homePage");
        if (obj == null) 
        {       
            Integer moduleId      = module.getModuleId();
            Criteria crit = new Criteria()
                .add(QueryPeer.DELETED, 0);
            crit.add(QueryPeer.HOME_PAGE, 1);
            crit.add(QueryPeer.MODULE_ID, moduleId);
            queries = QueryPeer.doSelect(crit);
            QueryManager.getMethodResult()
                .put(queries, QUERY_PEER, GET_MODULE_QUERIES, module, "homePage");
         }
        else 
        {
            queries = (List)obj;
        }
        
        Integer moduleOwnerId = module.getOwnerId();
        Query result = null;
        if(queries != null)
        {
            Iterator<Query> iter = queries.iterator();
            while(iter.hasNext())
            {
                Query candidate = iter.next();
                Integer candidateId = candidate.getUserId();
                Integer scopeId      = candidate.getScopeId();
                boolean isPrivateUserQuery = candidateId.equals(userId) && (scopeId == 1);
                boolean isGlobalQuery      = scopeId == 2;
                if( isPrivateUserQuery || isGlobalQuery )
                {
                    result = candidate; // We found a customized query.
                }
                if(isPrivateUserQuery)
                {
                    break; // It is the user's custom query. Take that and be happy.
                }
            }
            // Now result contains either the user's customized query, 
            // or the module owner's query, if the user hasn't configured one by himself,
            // or null, if no query could be found at all for either the user or the module owner.
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/NotificationStatusManager.java
public static List<NotificationStatus> getNotificationsFor(ScarabUser user) throws TorqueException
    {
        //NotificationStatusManager.getInstance().
        List result = null;
        Criteria crit = new Criteria()
        .add(NotificationStatusPeer.RECEIVER_ID, user.getUserId());
        crit.and(NotificationStatusPeer.STATUS, NotificationStatus.MARK_DELETED, Criteria.NOT_EQUAL);
        result = NotificationStatusPeer.doSelect(crit);
        return result;
    }
            
// in java/org/tigris/scarab/om/NotificationStatusManager.java
public static int getNotificationCount(Module module, ScarabUser user) throws TorqueException
    {
        List<NotificationStatus> notifications = getNotificationsFor(user);
        int count = 0;
        Iterator<NotificationStatus> iter = notifications.iterator();
        int currentModuleId = module.getModuleId();
        while(iter.hasNext())
        {
            NotificationStatus status = iter.next();
            long issueId  = status.getIssueId();
            Issue issue   = IssueManager.getInstance(issueId);
            int moduleId  = issue.getModuleId();
            if(moduleId == currentModuleId)
            {
                count++;
            }
        }
        return count;
    }
            
// in java/org/tigris/scarab/om/ScopePeer.java
public static List getAllScopes()
        throws TorqueException
    {
        return doSelect(new Criteria(0));
    }
            
// in java/org/tigris/scarab/om/ModuleManager.java
public static Module getInstance(String moduleDomain, 
                                     String moduleRealName, 
                                     String moduleCode)
        throws TorqueException
    {
        return getManager().getInstanceImpl(moduleDomain, moduleRealName, 
                                            moduleCode);
    }
            
// in java/org/tigris/scarab/om/ModuleManager.java
protected Module getInstanceImpl(final String moduleDomain, 
                                     final String moduleRealName, 
                                     final String moduleCode)
        throws TorqueException
    {
        final Criteria crit = new Criteria();
        if( moduleDomain != null )
        {
            crit.add(ScarabModulePeer.DOMAIN, moduleDomain);
        }
        if( moduleRealName != null )
        {
            crit.add(ScarabModulePeer.MODULE_NAME, moduleRealName);
        }
        if( moduleCode != null )
        {
            crit.add(ScarabModulePeer.MODULE_CODE, moduleCode);
        }
        final List result = ScarabModulePeer.doSelect(crit);
        if (result.size() != 1)
        {
            throw new TorqueException ("Selected: " + result.size() + 
                " rows. Expected 1."); //EXCEPTION
        }
        return (Module) result.get(0);
    }
            
// in java/org/tigris/scarab/om/ModuleManager.java
public static List getInstancesFromIssueList(List issues)
        throws TorqueException
    {
        if (issues == null) 
        {
            throw new IllegalArgumentException("Null issue list is not allowed."); //EXCEPTION
        }        

        List modules = new ArrayList();
        Iterator i = issues.iterator();
        if (i.hasNext()) 
        {
            Issue issue = (Issue)i.next();
            if (issue != null)
            {
                Module module = issue.getModule();
                if (module != null && !modules.contains(module)) 
                {
                    modules.add(module);
                }
            }
            else
            {
                throw new TorqueException("Null issue in list is not allowed."); //EXCEPTION
            }
        }
        return modules;
    }
            
// in java/org/tigris/scarab/om/ModuleManager.java
protected Persistent putInstanceImpl(Persistent om)
    throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        getMethodResult().removeAll((ScarabModule)om, ScarabModule.GET_DEFAULTREPORT);
        List listeners = (List)listenersMap.get(ReportPeer.REPORT_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/AttachmentManager.java
protected Persistent putInstanceImpl(Persistent om)
        throws TorqueException
    {
        Persistent oldOm = super.putInstanceImpl(om);
        List listeners = (List)listenersMap.get(AttachmentPeer.ISSUE_ID);
        notifyListeners(listeners, oldOm, om);
        return oldOm;
    }
            
// in java/org/tigris/scarab/om/AttachmentManager.java
public static Attachment getInstance(String id)
        throws TorqueException
    {
        return getInstance(new Long(id));
    }
            
// in java/org/tigris/scarab/om/AttachmentManager.java
public static Attachment getComment(Attachment attachment, Issue issue, 
                                        ScarabUser user)
         throws TorqueException
    {
        return populate(attachment, issue, Attachment.COMMENT__PK, "comment", 
                 user, "text/plain");
    }
            
// in java/org/tigris/scarab/om/AttachmentManager.java
public static Attachment getReason(Attachment attachment, Issue issue, 
                                        ScarabUser user)
         throws TorqueException
    {
        return populate(attachment, issue, Attachment.MODIFICATION__PK, "reason", 
                 user, "text/plain");
    }
            
// in java/org/tigris/scarab/om/AttachmentManager.java
private static Attachment populate(Attachment attachment,
                                      Issue issue, Integer typeId, 
                                      String name, ScarabUser user, 
                                      String mimetype)
         throws TorqueException
    {
        attachment.setIssue(issue);
        attachment.setTypeId(typeId);
        attachment.setName(name);
        attachment.setCreatedBy(user.getUserId());
        attachment.setMimeType(mimetype);
        attachment.save();
        return attachment;
    }
            
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static IssueType retrieveByPK(ObjectKey pk)
        throws TorqueException
    {
        IssueType result = null;
        Object obj = ScarabCache.get(ISSUE_TYPE_PEER, RETRIEVE_BY_PK, pk); 
        if (obj == null) 
        {        
            result = BaseIssueTypePeer.retrieveByPK(pk);
            ScarabCache.put(result, ISSUE_TYPE_PEER, RETRIEVE_BY_PK, pk);
        }
        else 
        {
            result = (IssueType)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static List getAllIssueTypes(boolean deleted,
                       String sortColumn, String sortPolarity)
        throws TorqueException
    {
        List result = null;
        Boolean b = deleted ? Boolean.TRUE : Boolean.FALSE;
        Object obj = ScarabCache.get(ISSUE_TYPE_PEER, GET_ALL_ISSUE_TYPES, b); 
        if (obj == null) 
        {        
            Criteria c = new Criteria();
            c.add(IssueTypePeer.PARENT_ID, 0);
            c.add(IssueTypePeer.ISSUE_TYPE_ID, 0, Criteria.NOT_EQUAL);
            if (deleted)
            {
                c.add(IssueTypePeer.DELETED, 1);
            }
            else
            {
                c.add(IssueTypePeer.DELETED, 0);
            }
            if (sortColumn != null && sortColumn.equals("desc"))
            {
                addSortOrder(c, IssueTypePeer.DESCRIPTION, 
                             sortPolarity);
            }
            else
            {
                // sort on name
                addSortOrder(c, IssueTypePeer.NAME, 
                             sortPolarity);
            }
            result = doSelect(c);
            ScarabCache.put(result, ISSUE_TYPE_PEER, GET_ALL_ISSUE_TYPES, b);
        }
        else 
        {
            result = (List)obj;
        }
        return result;
    }
            
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static List getAllIssueTypes(boolean includeDeleted)
        throws TorqueException
    {
        return getAllIssueTypes(includeDeleted, "name", "asc");
    }
            
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static List getDefaultIssueTypes()
        throws TorqueException
    {
        Criteria c = new Criteria();
        c.add(IssueTypePeer.PARENT_ID, 0);
        c.add(IssueTypePeer.DELETED, 0);
        c.add(IssueTypePeer.ISDEFAULT, 1);
        c.add(IssueTypePeer.ISSUE_TYPE_ID, 0, Criteria.NOT_EQUAL);
        return IssueTypePeer.doSelect(c);
    }
            
// in java/org/tigris/scarab/om/IssueTypePeer.java
public static boolean isUnique(String name, Integer id)
        throws TorqueException
    {
        boolean unique = true;
        name = name.trim();
        Criteria crit = new Criteria().add(IssueTypePeer.NAME, name);
        crit.setIgnoreCase(true);
        List types = IssueTypePeer.doSelect(crit);
        if (types.size() > 0) 
        {
            for (int i =0; i<types.size();i++)
            {
                IssueType it = (IssueType)types.get(i);
                if ((id == null ||  
                     (id != null && !it.getIssueTypeId().equals(id)))
                    && it.getName().trim().toLowerCase().equals(name.toLowerCase()))
                {
                    unique = false;
                }
            }
        }
        return unique;
    }
            
// in java/org/tigris/scarab/om/AttachmentType.java
public static AttachmentType getInstance(String attachmentTypeName)
        throws TorqueException,ScarabException
    {
        Criteria crit = new Criteria();
        crit.add(BaseAttachmentTypePeer.ATTACHMENT_TYPE_NAME, attachmentTypeName);
        List attachmentTypes = AttachmentTypePeer.doSelect(crit);
        if(attachmentTypes.size() > 1)
        {
            throw new ScarabException(L10NKeySet.ExceptionAttachmentDuplicateTypename);
        }
        return (AttachmentType)attachmentTypes.get(0);
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getTemplates(Module module, IssueType issueType,
                                    ScarabUser user, String sortColumn, 
                                    String sortPolarity, String type)
        throws TorqueException, ScarabException
    {
        List templates = null;
        Serializable[] key = {TEMPLATE_PEER, GET_TEMPLATES, module,
            issueType, user, sortColumn, sortPolarity, type};
        Object obj = ScarabCache.get(key);
        if (obj == null) 
        {        
            Criteria crit = new Criteria()
                .add(IssuePeer.MODULE_ID, module.getModuleId())
                .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MOVED, 0)
                .addJoin(ActivitySetPeer.TRANSACTION_ID, 
                         ActivityPeer.TRANSACTION_ID) 
                .addJoin(IssuePeer.ISSUE_ID, 
                         ActivityPeer.ISSUE_ID) 
                .add(IssuePeer.TYPE_ID, issueType.getTemplateId())
                .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID);
            crit.setDistinct();

            Criteria.Criterion cGlob = crit.getNewCriterion(
                IssueTemplateInfoPeer.SCOPE_ID, Scope.MODULE__PK,
                Criteria.EQUAL);
            cGlob.and(crit.getNewCriterion(IssueTemplateInfoPeer.APPROVED, 
                                           Boolean.TRUE, Criteria.EQUAL));
            Criteria.Criterion cPriv = crit.getNewCriterion(
                ActivitySetPeer.CREATED_BY, user.getUserId(),  
                Criteria.EQUAL);
            cPriv.and(crit.getNewCriterion(
                IssueTemplateInfoPeer.SCOPE_ID, Scope.PERSONAL__PK, 
                Criteria.EQUAL));

            if (TYPE_PRIVATE.equals(type))
            {
                crit.add(cPriv);
            }
            else if (TYPE_GLOBAL.equals(type))
            {
                crit.add(cGlob);
            }
            else
            {
                // All templates
                cGlob.or(cPriv);
                crit.add(cGlob);
            }

            // Add sort criteria
            if (sortColumn.equals("desc"))
            {
                addSortOrder(crit, IssueTemplateInfoPeer.DESCRIPTION, 
                             sortPolarity);
            }
            else if (sortColumn.equals("avail"))
            {
                crit.addJoin(IssueTemplateInfoPeer.SCOPE_ID,
                             ScopePeer.SCOPE_ID);
                addSortOrder(crit, ScopePeer.SCOPE_NAME, sortPolarity);
            }
            else if (!sortColumn.equals("user"))
            {
                // sort by name
                addSortOrder(crit, IssueTemplateInfoPeer.NAME, sortPolarity);
            }
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, key);
        }
        else 
        {
            templates = (List)obj;
        }
        if (sortColumn.equals("user"))
        {
            templates = sortByCreatingUser(templates, sortPolarity);
        }
        return templates;
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getUserTemplates(ScarabUser user, Module module,IssueType issueType)
        throws TorqueException, ScarabException
    {
        List templates = null;
        Object obj = ScarabCache.get(TEMPLATE_PEER, GET_USER_TEMPLATES, user);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
            .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID)
            .add(IssuePeer.DELETED, 0)
                .add(IssuePeer.MODULE_ID, module.getModuleId())
            .addJoin(ActivitySetPeer.TRANSACTION_ID, 
                     ActivityPeer.TRANSACTION_ID) 
                .addJoin(IssuePeer.ISSUE_ID, 
                         ActivityPeer.ISSUE_ID) 
            .add(IssuePeer.TYPE_ID, issueType.getTemplateId())
            .add(ActivitySetPeer.CREATED_BY, user.getUserId());
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, TEMPLATE_PEER, GET_USER_TEMPLATES, user);
        }
        else 
        {
            templates = (List)obj;
        }
        return templates;
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
public static List getModuleTemplates(Module module)
        throws TorqueException
    {
        List templates = null;
        Object obj = ScarabCache.get(TEMPLATE_PEER, GET_MODULE_TEMPLATES, module);
        if (obj == null) 
        {
            Criteria crit = new Criteria()
            .addJoin(IssueTemplateInfoPeer.ISSUE_ID,
                         IssuePeer.ISSUE_ID)
            .add(IssuePeer.DELETED, 0)
            .add(IssuePeer.MODULE_ID, module.getModuleId())
            .add(IssueTemplateInfoPeer.SCOPE_ID, Scope.MODULE__PK);
            templates = IssueTemplateInfoPeer.doSelect(crit);
            ScarabCache.put(templates, TEMPLATE_PEER, GET_USER_TEMPLATES, module);
        }
        else 
        {
            templates = (List)obj;
        }
        return templates;
    }
            
// in java/org/tigris/scarab/om/IssueTemplateInfoPeer.java
private static List sortByCreatingUser(List result,
                                           String sortPolarity)
        throws TorqueException
    {
        final int polarity = ("asc".equals(sortPolarity)) ? 1 : -1;   
        Comparator c = new Comparator() 
        {
            public int compare(Object o1, Object o2) 
            {
                int i = 0;
                try
                {
                    i = polarity * 
                        ((Issue)o1).getCreatedBy().getFirstName()
                         .compareTo(((Issue)o2).getCreatedBy().getFirstName());
                }
                catch (Exception e)
                {
                    //
                }
                return i;
             }
        };
        Collections.sort(result, c);
        return result;
    }
            
// in java/org/tigris/scarab/om/Report.java
public Module getModule() 
        throws TorqueException
    {
        return ModuleManager.getInstance(getModuleId());
    }
            
// in java/org/tigris/scarab/om/Report.java
public void setModule(Module  v) 
        throws TorqueException
    {
        setModuleId(v.getModuleId());
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public List getAncestors()
        throws TorqueException
    {
        List options = new ArrayList();
        addAncestors(options);
        return options;
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
private void addAncestors(List ancestors)
        throws TorqueException
    {
        List parents = getParents();
        for (int i=parents.size()-1; i>=0; i--) 
        {
            AttributeOption parent = (AttributeOption) 
                parents.get(i);
            if (!ancestors.contains(parent)) 
            {
                ancestors.add(parent);    
                parent.addAncestors(ancestors);
            }
        }
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public List getDescendants()
        throws TorqueException
    {
        List options = new ArrayList();
        addDescendants(options);
        return options;
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
private void addDescendants(List descendants)
        throws TorqueException
    {
        List children = getChildren();
        for (int i=children.size()-1; i>=0; i--)
        {
            AttributeOption child = (AttributeOption)
                children.get(i);
            descendants.add(child);
            child.addDescendants(descendants);
        }
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public List getChildren()
        throws TorqueException
    {
        if (sortedChildren == null)
        {
            buildChildren();
        }
        return sortedChildren;
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public List getParents()
        throws TorqueException
    {
        List sortedParents = (List)AttributeOptionManager.getMethodResult().get(
            this, AttributeOptionManager.GET_PARENTS
        );
        if ( sortedParents == null )
        {
            sortedParents = buildParents();
            AttributeOptionManager.getMethodResult().put(
                sortedParents, this, AttributeOptionManager.GET_PARENTS
            );
        }
        return sortedParents;
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
private synchronized void buildChildren()
        throws TorqueException
    {
        Criteria crit = new Criteria()
            .add(ROptionOptionPeer.RELATIONSHIP_ID, 
                 OptionRelationship.PARENT_CHILD)
            .add(ROptionOptionPeer.OPTION1_ID,
                 super.getOptionId());

        List relations = ROptionOptionPeer.doSelect(crit);
        sortedChildren = new ArrayList(relations.size());
        for (int i=0; i < relations.size(); i++)
        {
            ROptionOption relation = (ROptionOption)relations.get(i);
            Integer key = relation.getOption2Id();
            if (key != null)
            {
                sortedChildren.add(relation.getOption2Option());
            }
        }
        sortChildren();
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
private synchronized List buildParents()
        throws TorqueException
    {
        Criteria crit = new Criteria()
            .add(ROptionOptionPeer.RELATIONSHIP_ID, 
                 OptionRelationship.PARENT_CHILD)
            .add(ROptionOptionPeer.OPTION2_ID,
                 super.getOptionId());
        List relations = ROptionOptionPeer.doSelect(crit);

        List sortedParents = new ArrayList(relations.size());
        for (int i=0; i < relations.size(); i++)
        {
            ROptionOption relation = (ROptionOption)relations.get(i);
            Integer key = relation.getOption1Id();
            if (key != null)
            {
                sortedParents.add(relation.getOption1Option());
            }
        }
        Collections.sort(sortedParents, getComparator());

        return sortedParents;
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean isChildOf(AttributeOption parent)
        throws TorqueException
    {
        return getParents().contains(parent);
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean isParentOf(AttributeOption child)
        throws TorqueException
    {
        return getChildren().contains(child);
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean hasChildren()
        throws TorqueException
    {
        return getChildren().size() > 0 ? true : false;
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean hasParents()
        throws TorqueException
    {
        return getParents().size() > 0 ? true : false;
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public AttributeOption getParent()
        throws TorqueException
    {
        AttributeOption parent = null;
        List parents = getParents();
        if (parents.size() == 1)
        {
           parent = (AttributeOption) parents.get(0);
        }
        return parent;
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public void deleteModuleMappings()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RModuleOptionPeer.OPTION_ID, getOptionId());
        RModuleOptionPeer.doDelete(crit);
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public void deleteIssueTypeMappings()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
        RIssueTypeOptionPeer.doDelete(crit);
        ScarabCache.clear();
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
private List getIssueTypesWithMappings()
        throws TorqueException
    {
        Criteria crit = new Criteria();
        crit.add(RIssueTypeOptionPeer.OPTION_ID, getOptionId());
        crit.addJoin(RIssueTypeOptionPeer.ISSUE_TYPE_ID, 
                     IssueTypePeer.ISSUE_TYPE_ID);
        return IssueTypePeer.doSelect(crit);
    }
            
// in java/org/tigris/scarab/om/AttributeOption.java
public boolean isSystemDefined()
        throws TorqueException
    {
        boolean systemDefined = false;
        List issueTypeList = getIssueTypesWithMappings();
        for (Iterator i = issueTypeList.iterator(); 
             i.hasNext() && !systemDefined;)
        {
            systemDefined = ((IssueType)i.next()).isSystemDefined();
        }
        return systemDefined;
    }
            
// in java/org/tigris/scarab/om/UserPreferenceManager.java
public static UserPreference getInstance(Integer userid)
        throws TorqueException
    {
        if (userid == null)
        {
            throw new IllegalArgumentException("User ID cannot be null"); //EXCEPTION
        }

        UserPreference up = null;
        try
        {
            up = BaseUserPreferenceManager.getInstance(userid);
        }
        catch (TorqueException te)
        {
            // Empty result...Failed to select one and only one row.
        }
        if (up == null)
        {
            up = UserPreferenceManager.getInstance();
            up.setUserId(userid);
        }
        return up;
    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private void logNotificationData(NotificationStatus notification) throws TorqueException
    {
        try
        {
            log.error("queueNotifications():comment:"      + notification.getComment());
            log.error("queueNotifications():changeDate:"   + notification.getChangeDate());
            log.error("queueNotifications():creationDate:" + notification.getCreationDate());
            log.error("queueNotifications():creator:"      + notification.getCreator().toString());
            log.error("queueNotifications():issueId:"      + notification.getIssueId());
            log.error("queueNotifications():primaryKey:"   + notification.getPrimaryKey().toString());
            log.error("queueNotifications():queryKey:"     + notification.getQueryKey());
            log.error("queueNotifications():receiver:"     + notification.getReceiver().toString());
            log.error("queueNotifications():status:"       + notification.getStatusLabel());
        }
        catch(Exception e)
        {
            log.error("queueNotifications(): while dumping notificationData: " + e.getMessage(),e);
        }
    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private void createWakeupNotification(Issue issue, ScarabUser user, String wakeupMessage) throws TorqueException
    {
        Date date;
        try {
            date = issue.getOnHoldUntil();
        } catch (Exception e) 
        {
            throw new RuntimeException("Can not retrieve the onHoldUntil date from the current issue");
        }
            Activity activity = ActivityManager.getInstance();
            Attribute attribute = issue.getMyStatusAttribute();

            activity.setAttribute(attribute);
            activity.setActivityType(ActivityType.ISSUE_ONHOLD.getCode());
            activity.setDescription("WakeupFromOnHoldstate");
            activity.setIssue(issue);
            activity.setEndDate(date);
            activity.setNewValue("");
            activity.setOldValue("");
            activity.setOldOptionId(0);
            activity.setNewOptionId(0);
            
            Attachment attachment = AttachmentManager.getInstance();
            attachment.setTextFields(user, issue,Attachment.COMMENT__PK);
            attachment.setData(wakeupMessage);
            attachment.setName("comment");
            attachment.save();
            
            activity.setAttachment(attachment);
            
            Integer tt = ActivitySetTypePeer.EDIT_ISSUE__PK;
            ActivitySet activitySet;
            try {
                activitySet = ActivitySetManager.getInstance(tt, user);
                activitySet.addActivity(activity);
                activitySet.save();
                
                addActivityNotification(ActivityType.ISSUE_REMINDER, activitySet, issue, user);                
            } catch (ScarabException e) {
                throw new RuntimeException(e);
            }
    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private boolean getIsStatusAttribute(Attribute attribute, Issue issue)
    throws TorqueException
    {
        Attribute statusAttribute = issue.getMyStatusAttribute();
        if(statusAttribute == null)
        {
            return false;
        }
        boolean result = statusAttribute.equals(attribute);
        return result;
    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
private String[] getFromUser(Issue issue, EmailContext context) throws TorqueException
    {
        String[] replyToUser = null;
    
        Set creators = (Set)context.get("creators");
        if (creators.size()==1)
        {
            // exactly one contributor to this E-Mail
            boolean exposeSender = Turbine.getConfiguration()
            .getBoolean("scarab.email.replyto.sender",false);

            if(exposeSender)
            {
                ScarabUser creator = (ScarabUser)creators.toArray()[0];
                replyToUser = new String[] { creator.getName(), creator.getEmail() };
            }
        }
        
        if(replyToUser == null)
        {
         replyToUser = issue.getModule().getSystemEmail();
        }
        
        return replyToUser;
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public void setIssue(Issue issue) throws TorqueException
    {
        this.module     = issue.getModule();
        this.issue      = issue;
        this.conditions = null;
        this.rules      = null;
        this.optionIds  = null;
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public boolean isRequiredIf(Integer optionID) throws TorqueException 
    {
        boolean isRequired = getOptionIds().contains(optionID);
        return isRequired;
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public void setConditionsArray(Integer[] optionId, Integer operator) throws TorqueException 
    {
        NotificationRulePeer.saveConditions(user, module, optionId, operator);
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public List<Condition> getConditions() throws TorqueException
    {
        if(conditions == null)
        {
            conditions = NotificationRulePeer.getConditions(user, module);
        }
        return conditions;
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public List<NotificationRule> getRules() throws TorqueException
    {
        if(rules == null)
        {
            NotificationRulePeer.getNotificationRules(user, module);
        }
        return rules;
    }
            
// in java/org/tigris/scarab/notification/Notification.java
private Set<Integer> getOptionIds() throws TorqueException 
    {
        Iterator<Condition> iter = getConditions().iterator();
        Set<Integer>optionIds = new HashSet<Integer>();
        while(iter.hasNext())
        {
            Condition condition = iter.next();
            Integer optionId = condition.getOptionId();
            if(optionId != null)
            {
                optionIds.add(optionId);
            }
        }
        return optionIds;
    }
            
// in java/org/tigris/scarab/notification/Notification.java
public boolean sendConditionsMatch() throws TorqueException 
    {
        List<Condition> conditions = getConditions();
        if(conditions.size() == 0)
        {
            return true; // no conditions defined, hence no constraints, hence return true
        }
        
        Map<String,AttributeValue> attributeValues =  issue.getModuleOptionAttributeValuesMap();
        Integer operator = getConditionOperator();
        
        Iterator<Condition> iter = conditions.iterator();
        Set<Integer>attributeIds = new HashSet<Integer>();

        String forIssueId = "";
        if(this.issue!=null)
        {
            forIssueId = "for issue " + this.issue.getIdPrefix()+ this.issue.getIdCount();
        }
        log.info("test sendNotification conditions "+forIssueId+" -------------");
        
        int matchCounter = 0;
        while(iter.hasNext())
        {
            Condition condition = iter.next();
            AttributeOption ao  = condition.getAttributeOption();
            int optionId = ao.getOptionId();
            Attribute attribute = ao.getAttribute();
            int attributeId = attribute.getAttributeId();
            attributeIds.add(attributeId);
            
            AttributeOption option = AttributeOptionManager.getInstance(optionId);
            
            //log.info("test for " + attribute.getName() + "=\"" + option.getName()    + "\"  (att:" + + attributeId + ",opt:" + optionId+")");
            
            Iterator<Entry<String,AttributeValue>> attvalIterator = attributeValues.entrySet().iterator();
            while( attvalIterator.hasNext())
            {
                Entry<String,AttributeValue> e = attvalIterator.next();
                AttributeValue av = e.getValue();
                int attvalAttributeId = av.getAttributeId();
                Attribute att = av.getAttribute();
                AttributeOption attOpt = av.getAttributeOption();
                if(attributeId == attvalAttributeId)
                {
                    int aoi = av.getOptionId();
                    boolean match = aoi == optionId;
                    //log.info( ((match)? "match ":"      ") + att.getName()       + "=\"" + attOpt.getName()    + "\"  (att:" + attvalAttributeId + ",opt:" + attOpt.getOptionId());
                    if( match)
                    {
                        String sendConditionMet = "SendCondition met. ("+attribute.getName() + "=\"" + option.getName()+")";
                        matchCounter++;
                        if ( operator.equals(OR) )
                        {
                            log.info(sendConditionMet + " -> (send notification)");
                            return true;  // quick exit. first match gives success.
                        }
                        log.info(sendConditionMet);
                        break; // we can break the inner iteration (we found the match)
                    }                    
                }
            }
            
        }

        boolean match; // just in case no condition is defined, we return true
        if(operator.equals(AND) && attributeIds.size() == matchCounter)
        {
            log.info("SendCondition met. (all conditions matched)");
            match = true; // operator 
        }
        else
        {
            if (matchCounter > 0)
            {
                log.info("Only " + matchCounter + " send Conditions out of "+attributeIds.size()+" met. (Send is not triggered.)");
            }
            else
            {
                log.info("None of the " + attributeIds.size() + " available conditions was applicable to this issue. (Send is not triggered.)" );
            }
            match = false;
        }
        
        return match;
    }
            
// in java/org/tigris/scarab/xmlrpc/NewTicketHandler.java
public String createNewTicket( String moduleCode, 
								   String issueTypeName, 
								   String userName, 
								   Hashtable attribs) throws TorqueException, ScarabException {
		
		//init environment for the new issue
		Module module = ModuleManager.getInstance(null, null, moduleCode);
		IssueType issueType = IssueType.getInstance(issueTypeName);
		Issue issue = module.getNewIssue(issueType);
		ScarabUser user = ScarabUserManager.getInstance(userName);
        
        Attachment reason = new Attachment();
        reason.setData("Created by xmlrpc");
        reason.setName("reason");
        
        //init issue, set and store attributes
		ActivitySet activitySet = null;
        activitySet = issue.setInitialAttributeValues(activitySet, reason, new HashMap(), user);

        // Save any unsaved attachments as part of this ActivitySet as well.
        setAttributes(issue,activitySet,reason,user,attribs);
        activitySet = issue.doSaveFileAttachments(activitySet, user);
        activitySet.save();
        
        return issue.getUniqueId();
	}
            
// in java/org/tigris/scarab/xmlrpc/NewTicketHandler.java
private void setAttributes(Issue issue, ActivitySet activitySet, Attachment attachment, ScarabUser user, Hashtable attribs) throws TorqueException, ScarabException {

        LinkedMap avMap = issue.getModuleAttributeValuesMap(false); 
        HashMap newValues = new HashMap();
        
        for (MapIterator i = avMap.mapIterator();i.hasNext();) 
        {
            AttributeValue aval = (AttributeValue)avMap.get(i.next());
        	String key = aval.getAttribute().getName();
        	String newValue = (String)attribs.get(key);
        	
        	if (newValue != null) {
        		AttributeValue newVal = aval.copy();
        		newVal.setValue(newValue);
				newValues.put(aval.getAttributeId(),newVal);
        	}
        }
        issue.setAttributeValues(activitySet, newValues, attachment, user);
	}
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        // find the corresponding attribute
        Attribute attr;
        Criteria crit = new Criteria();
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        List attrList = AttributePeer.doSelect(crit);
        if (attrList.size() == 1) {
            attr = (Attribute) attrList.get(0);
        } else {
            throw new ScarabUpdateException(
                    "Found " + attrList.size() + " attributes for " + attribute + ".");
        }
        return attr;
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private Attribute getOptionAttribute(String attribute)
            throws ScarabUpdateException, TorqueException {
        Attribute attr = getAttribute(attribute);
        if (attr.isOptionAttribute()) {
            // do nothing
        } else {
            throw new ScarabUpdateException(
                    "Found non-optiontype attribute when an option type attribte was expected.");
        }
        return attr;
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
public List getAttributeOptions(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.add(AttributeOptionPeer.DELETED, false);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                AttributeOptionPeer.ATTRIBUTE_ID);
        return AttributeOptionPeer.doSelect(crit);
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private List getModuleAttributes(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                RModuleAttributePeer.ATTRIBUTE_ID);
        List matOptions = RModuleAttributePeer.doSelect(crit);

        return matOptions;
    }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
private List getIssueTypes(String attribute) throws TorqueException,
            ScarabUpdateException {
        Criteria crit = new Criteria();

        // get all non-deleted options for this attribute
        crit.add(AttributePeer.ATTRIBUTE_NAME, (Object) attribute,
                Criteria.EQUAL);
        crit.addJoin(AttributePeer.ATTRIBUTE_ID,
                RIssueTypeAttributePeer.ATTRIBUTE_ID);
        crit.addJoin(IssueTypePeer.ISSUE_TYPE_ID,
                RIssueTypeAttributePeer.ISSUE_TYPE_ID);
        List itOptions = IssueTypePeer.doSelect(crit);

        return itOptions;
    }
            
// in java/org/tigris/scarab/feeds/IssueFeed.java
public SyndFeed getFeed() throws IOException, FeedException, TorqueException, Exception {

        SyndFeed feed = new SyndFeedImpl();
       
        String title = issue.getUniqueId() + ": " + issue.getDefaultText();
        feed.setTitle(title);
        String link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
        feed.setLink(link);
        feed.setDescription(title);

        List entries = new ArrayList();
        List allActivities = issue.getActivity(true);
        

        for (Iterator i = allActivities.iterator(); i.hasNext();) {
            SyndEntry entry;
            SyndContent description;
            
            Activity activity = (Activity)i.next();
            
            ActivitySet activitySet = activity.getActivitySet();
            Date date =activitySet.getCreatedDate();
            entry = new SyndEntryImpl();

            entry.setPublishedDate(date);
            
            description = new SyndContentImpl();
            description.setType("text/html");
            
            String desc =
                  "<b>Description:</b>" + activity.getDisplayName(this.l10nTool) +"<br/>"
                + "<b>New:</b>" + activity.getNewValue(this.l10nTool) +"<br/>"
                + "<b>Old:</b>" + activity.getOldValue(this.l10nTool) +"<br/>"
                + "<b>Reason:</b>" + activitySet.getCommentForHistory(issue) +"<br/>";
            
            entry.setAuthor(activitySet.getCreator().getName());

            description.setValue(desc.toString());            

			String entryTitle = createEntryTitle(activity);
            entry.setTitle(entryTitle);
            
            entry.setDescription(description);
            
            //The hashCode is a cheap trick to have a unique link tag in the RSS feed
            //to help those reader as ThunderBird that use the link to check for new items
            entry.setLink(link+"?hash="+entry.hashCode());
            
            entries.add(entry);
        }
     

        feed.setEntries(entries);
        
        return feed;
    }
            
// in java/org/tigris/scarab/feeds/QueryFeed.java
public SyndFeed getFeed() throws Exception, TorqueException, DataSetException, TurbineSecurityException
    {
        SyndFeed feed = new SyndFeedImpl();
        feed.setTitle(query.getName());
        String link = scarabLink.setAction("Search").addPathInfo("go",query.getQueryId()).toString();
        feed.setLink(link);
        feed.setDescription(query.getDescription());
        List entries = new ArrayList();
        for(Iterator i = results.iterator(); i.hasNext();)
        {
            SyndEntry entry = new SyndEntryImpl();
            SyndContent description = new SyndContentImpl();
            QueryResult queryResult = (QueryResult)i.next();
            String title = queryResult.getUniqueId();
            entry.setTitle(title);
            
            Issue issue = IssueManager.getInstance(Long.valueOf(queryResult.getIssueId()));

            link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
            entry.setLink(link);

            Date publishedDate = null;
            if(issue.getModifiedDate()!= null){
                publishedDate = issue.getModifiedDate();
            }
            else {
                publishedDate = issue.getCreatedDate();
            }
            entry.setPublishedDate(publishedDate);

            description = new SyndContentImpl();
            description.setType("text/html");
            String desc = "";
            Iterator avIteratorCSV = queryResult.getAttributeValuesAsCSV().iterator();
            Iterator avIterator = query.getMITList().getAllRModuleUserAttributes().iterator();
            while (avIterator.hasNext())
            {
                String value = (String)avIteratorCSV.next();
                RModuleUserAttribute av = (RModuleUserAttribute)avIterator.next();
                desc = desc + "<b>" + av.getAttribute().getName()+":</b>" + value +"<br/>";
            }
            description.setValue(ScarabUtil.filterNonXml(desc));

            entry.setDescription(description);
            entries.add(entry);
        }
        feed.setEntries(entries);
        feed.setFeedType(format);
        return feed;
    }
            
// in java/org/tigris/scarab/actions/Search.java
public void doGetissues(RunData data, TemplateContext context) throws TorqueException
    {
        try
        {
            setup(data, context);
        }
        catch(Exception e)
        {
            // no module selected
            return;
        }
        
        ParameterParser pp = data.getParameters();
        Module module = user.getCurrentModule();

        MITList mitList;
        int issueTypeId = pp.getInt("issueType");
        if(issueTypeId > 0)
        {
            // search only within specidied issueType
            IssueType issueType = IssueTypeManager.getInstance(new Integer(issueTypeId));
            mitList = MITListManager.getSingleItemList(module, issueType, user);
        }
        else
        {
            // search all issueTypes in current module
            mitList = MITListManager.getSingleModuleAllIssueTypesList(module, user);            
        }

        user.setCurrentMITList(mitList);
        int optionId    = pp.getInt("option");

        if (optionId > 0)
        {
            // search only issues with given attribute set to given value
            Integer oid = new Integer(optionId);
            AttributeOption ao = AttributeOptionManager.getInstance(oid);
            Integer attId = ao.getAttributeId();
            Attribute attribute = AttributeManager.getInstance(attId);

            AttributeValue av = AttributeValue.getNewInstance(attribute, null);
            String aoname = ao.getName();
            attributeSearch(aoname, av, user);
        }
        else
        {
            // search all issues in current MITList (see MITList initializatoin above)
            processSearch("",  user);
        }

        return;
    }
            
// in java/org/tigris/scarab/actions/DefineXModuleList.java
private void addToUsersList(ScarabUser user, MITList list)
        throws TorqueException
    {
        MITList currentList = user.getCurrentMITList();
        if (currentList == null) 
        {
            currentList = MITListManager.getInstance();
            user.setCurrentMITList(currentList);
        }
        
            currentList.addAll(list);
    }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
private void updateModuleParameters(RunData data, Module me) throws TorqueException
    {
        ParameterParser pp = data.getParameters();

        // Update email overrides
        if (GlobalParameterManager.getBoolean(
                GlobalParameter.EMAIL_ALLOW_MODULE_OVERRIDE,me)) 
        {
            String name;
            for (int i=0; i<EMAIL_PARAMS.length; i++) 
            {
                name = EMAIL_PARAMS[i];
                storeGlobalParameterAsBoolean(name, me, pp);
            }
        }

        // update all global module parameters in database
        storeGlobalParameter(GlobalParameter.ISSUE_REASON_REQUIRED, me, pp);
        storeGlobalParameterAsBoolean(GlobalParameter.ISSUE_REASON_HIDDEN, me, pp);
        storeGlobalParameter(GlobalParameter.REQUIRED_ROLE_FOR_REQUESTING_ACCESS, me, pp);
        storeGlobalParameter(GlobalParameter.COMMENT_RENDER_ENGINE, me, pp);
        storeGlobalParameter(GlobalParameter.DEFAULT_REPORT, me, pp);
        
    }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
private void storeGlobalParameterAsBoolean(String name, Module me, ParameterParser pp) throws TorqueException
    {
        boolean storageValue = pp.getBoolean(name);
        GlobalParameterManager
        .setBoolean(name, me, storageValue);
    }
            
// in java/org/tigris/scarab/actions/ModifyModule.java
private void storeGlobalParameter(String name, Module me, ParameterParser pp) throws TorqueException
    {
        String requiredRole = pp.getString(name);
        if (null == requiredRole)
        {
            requiredRole = "";
        }
        GlobalParameterManager.setString(name, me, requiredRole);
    }
            
// in java/org/tigris/scarab/actions/QueryList.java
private boolean setStartpage(List<Query> queries, Query newStartQuery) throws TorqueException
    {
        boolean addedAsStartQuery = false;
        Iterator<Query> iter = queries.iterator();
        while(iter.hasNext())
        {
            Query query = iter.next();
            if (query.getQueryId().equals(newStartQuery.getQueryId()))
            {
                query.setHomePage(true);
                addedAsStartQuery=true;
            }
            else
            {
                query.setHomePage(false);
            }
            query.save();
        }
        return addedAsStartQuery;
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
public void doDelete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        IntakeTool intake = getIntakeTool(context);
        Group attrGroup = intake.get("ConditionEdit", IntakeTool.DEFAULT_KEY);
        data.getParameters().remove(attrGroup.get("ConditionsArray").getKey());
        updateObject(data, context, null);
    }
            
// in java/org/tigris/scarab/actions/admin/BaseConditionEdit.java
private void delete(RunData data, TemplateContext context) throws TorqueException, Exception
    {
        int nObjectType = data.getParameters().getInt("obj_type");
        Criteria crit = new Criteria();
        switch (nObjectType)
        {
            case ScarabConstants.TRANSITION_OBJECT:
            	Integer tranId = data.getParameters().getInteger("transition_id");
            	crit.add(ConditionPeer.TRANSITION_ID, tranId);
            	TransitionManager.getMethodResult().remove(TransitionManager.getInstance(tranId), TransitionManager.GET_CONDITIONS);
                break;
            case ScarabConstants.GLOBAL_ATTRIBUTE_OBJECT:
                crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, 0);
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, 0);
                break;
            case ScarabConstants.MODULE_ATTRIBUTE_OBJECT:
        		crit.add(ConditionPeer.ATTRIBUTE_ID, data.getParameters().getInt("attId"));
            	crit.add(ConditionPeer.MODULE_ID, data.getParameters().getInt("module_id"));
            	crit.add(ConditionPeer.ISSUE_TYPE_ID, data.getParameters().getInt("issueTypeId"));
        		break;
            case ScarabConstants.NOTIFICATION_ATTRIBUTE_OBJECT:
                ScarabRequestTool scarabR = getScarabRequestTool(context);
                ScarabUser user = (ScarabUser)data.getUser();
                if(user == null)
                {
                    throw new TorqueException("No user found in RunData during Notification customization (constraints on attributes)");
                }
                Module module = scarabR.getCurrentModule();
                if(module == null)
                {
                    throw new TorqueException("No module found in RunData during Notification customization (constraints on attributes)");
                }
                NotificationRulePeer.deleteConditions(user, module);
                return;
        }
        ConditionPeer.doDelete(crit);
    	ConditionManager.clear();
    	TransitionManager.clear();
    }
            
// in java/org/tigris/scarab/actions/ChangeNotificationStatus.java
private void modifyInDatabase(NotificationRule rule) throws TorqueException, Exception
    {
        if (equalsDefaultCustomization(rule))
        {
            if (rule.isNew())
            {
                // don't need to create this rule
            }
            else
            {
                // can safely remove this rule
                ObjectKey pk = rule.getPrimaryKey();
                NotificationRulePeer.doDelete(pk);
            }
         }
        else
        {
            // need to store this rule
            rule.save();
        }
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
private int removeUserFromIssue(ScarabUser user, Issue issue) throws TorqueException
    {
        return removeUserFromIssue(user, null, issue);
    }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
private int removeUserFromIssue(ScarabUser user, Attribute attribute, Issue issue) throws TorqueException
    {
        Set<ArrayList> userSet = issue.getAssociatedUsers();
        return removeUserFromUserSet(user, attribute, userSet);
   }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
private int removeUserFromUserSet(ScarabUser user, Attribute attribute, Set<ArrayList> userSet) throws TorqueException
    {
        Integer userId = user.getUserId();
        Iterator<ArrayList> iter = userSet.iterator();
        Collection toBeRemoved = new ArrayList();

        while(iter.hasNext())
        {
            ArrayList entry = iter.next();
            ScarabUser su = (ScarabUser)entry.get(1);

            if (su.equals(user))
            {
                if(attribute != null)
                {
                    Attribute entryAttribute = (Attribute)entry.get(0);
                    if (!entryAttribute.equals(attribute))
                    {
                        continue;
                    }
                }
                toBeRemoved.add(entry);
            }

        }
        

        userSet.removeAll(toBeRemoved);
        int removeCounter = toBeRemoved.size();
        
        return removeCounter;
   }
            
// in java/org/tigris/scarab/actions/AssignIssue.java
private int addUsersToList(ScarabUser user, Module module, Map userAttributes, StringBuffer msg) throws Exception, TorqueException
    {
        int returnCode;
        Map userMap = user.getAssociatedUsersMap();
        if (userAttributes != null && userAttributes.size() > 0) 
        {
            boolean isUserAttrRemoved = false;
            List removedUserAttrs = null;
            for (Iterator it = userAttributes.keySet().iterator(); it.hasNext(); )
            {
                String userId = (String)it.next();
                List item = new ArrayList();
                String attrId = (String)userAttributes.get(userId);
                Attribute attribute = AttributeManager
                    .getInstance(new Integer(attrId));
                ScarabUser su = ScarabUserManager
                    .getInstance(new Integer(userId));
                item.add(attribute);
                item.add(su);
                List issues = (List)user.getAssignIssuesList();
                for (int j=0; j<issues.size(); j++)
                {
                    Issue issue = (Issue)issues.get(j);
                    Long issueId = issue.getIssueId();
                    Set userList = (Set) userMap.get(issueId);
                    if (userList == null)
                    {
                        userList = new HashSet();
                    }
                    List<Attribute> attributeList = module
                        .getUserAttributes(issue.getIssueType(), true);
                    if (!attributeList.contains(attribute))
                    {
                        if (removedUserAttrs == null)
                        {
                            removedUserAttrs = new ArrayList();
                            removedUserAttrs.add(attribute);
                            msg.append("'").append(attribute.getName())
                                .append("'");
                        }
                        else if (!removedUserAttrs.contains(attribute))
                        {
                            removedUserAttrs.add(attribute);
                            msg.append(", '").append(attribute.getName())
                                .append("'");
                        }
                        isUserAttrRemoved = true;
                    }
                    else
                    {
                        removeUserFromUserSet(su, null, userList); // remove all user entries from set.
                        cleanupMultiAssignEntries(attribute, userList, attributeList);
                        userList.add(item);
                        // userMap.put(issueId, userList);
                        // user.setAssociatedUsersMap(userMap);
                    }
                } 
            }
            if (!isUserAttrRemoved)
            {
                returnCode = USERS_ADDED;
            }
            else 
            {
                returnCode = USERS_REMOVED;
            }
        }
        else
        {
            returnCode = ERR_NO_USERS_SELECTED;
        }
        return returnCode;
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setQueryKey(String key)
        throws TorqueException
    {
        torqueReport.setQueryKey(key);
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setScopeId(Integer id)
        throws TorqueException
    {
        torqueReport.setScopeId(id);
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setUserId(Integer id)
        throws TorqueException
    {
        torqueReport.setUserId(id);
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public Scope getScope()
        throws TorqueException
    {
        return torqueReport.getScope();
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public Module getModule() 
        throws TorqueException
    {
        Module module = null;
        if (torqueReport.getModuleId() != null) 
        {
            module = ModuleManager.getInstance(torqueReport.getModuleId());
        }
        
        return module;
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setModule(Module  v) 
        throws TorqueException
    {
        reportDefn.setModuleIssueTypes(null);
        if (v == null) 
        {
            torqueReport.setModuleId((Integer)null);            
        }
        else 
        {
            torqueReport.setModuleId(v.getModuleId());
            if (torqueReport.getIssueTypeId() != null) 
            {
                ModuleIssueType mit = new ModuleIssueType();
                mit.setModuleId(v.getModuleId());
                mit.setIssueTypeId(torqueReport.getIssueTypeId());
                reportDefn.addModuleIssueType(mit);
            }
        }
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public void setIssueType(IssueType  v) 
        throws TorqueException
    {
        reportDefn.setModuleIssueTypes(null);
        if (v == null) 
        {
            // issue type id cannot be null
            torqueReport.setIssueTypeId(ScarabConstants.INTEGER_0);
        }
        else 
        {
            torqueReport.setIssueTypeId(v.getIssueTypeId());
            if (torqueReport.getModuleId() != null) 
            {
                ModuleIssueType mit = new ModuleIssueType();
                mit.setModuleId(torqueReport.getModuleId());
                mit.setIssueTypeId(v.getIssueTypeId());
                reportDefn.addModuleIssueType(mit);
            }
        }
    }
            
// in java/org/tigris/scarab/reports/ReportBridge.java
public MITList getMITList()
        throws TorqueException
    {
        MITList mitList = null;
        List mits = reportDefn.getModuleIssueTypes();
        if (mits != null) 
        {
            Log.get().debug("mits were not null");
            mitList = new MITList();
            
            mitList.setScarabUser(this.torqueReport.getScarabUser());
            
            for (Iterator i = mits.iterator(); i.hasNext();) 
            {
                ModuleIssueType mit = (ModuleIssueType)i.next();
                MITListItem item = new MITListItem();
                item.setModuleId(mit.getModuleId());
                item.setIssueTypeId(mit.getIssueTypeId());
                mitList.addMITListItem(item);
            }
        }
        
        return mitList;
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
public List filterConditionalTransitions(List transitions, Issue issue) throws TorqueException {
        try {
            boolean blockedIssue = issue.isBlocked();
            if (transitions != null) {
                for (int i=transitions.size()-1; i>=0; i--) {
                    Transition tran = (Transition)transitions.get(i);
                    if (blockedIssue && tran.getDisabledIfBlocked()) {
                        transitions.remove(i);
                        continue;
                        
                    }
                    List conditions = tran.getConditions();
                    if (null != conditions && conditions.size() > 0) {
                        boolean bRemove = true;
                        for (Iterator itReq = conditions.iterator(); bRemove && itReq.hasNext(); ) {
                            Condition cond = (Condition)itReq.next();
                            bRemove = !evaluate(cond, issue);
                        }
                        if (bRemove) {
                            transitions.remove(i);
                        }
                    }
                }
            }
        } catch (Exception e) {
            Log.get().error("filterConditionalTransitions: " + e);
        }
        
        return transitions;
    }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
private boolean evaluate(final Condition cond, final Issue issue) throws TorqueException {
        boolean bEval = false;
        Attribute requiredAttribute = cond.getAttributeOption().getAttribute();
        Integer optionId = cond.getOptionId();
        AttributeValue av = issue.getAttributeValue(requiredAttribute);
        if (av != null) {
            Integer issueOptionId = av.getOptionId();
            if (issueOptionId != null && issueOptionId.equals(optionId)) {
                bEval = true;
            }
        }
        return bEval;
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public  SkipFiltering createIssueChecker(String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        String result = "";
        List<Attribute> attributes = null;
        Module module = issue.getModule();
        IssueType issueType = issue.getIssueType();
        attributes = issueType.getActiveAttributes(module);
        Iterator<Attribute> iter = attributes.iterator();
        while (iter.hasNext())
        {
            Attribute attribute = iter.next();
            RModuleAttribute rma  = module.getRModuleAttribute(attribute, issueType);
            result += createIssueChecker(rma, setMarkerFunction, indent);
        }
        
        String prepend;
        if(result.length() > 0)
        {
            prepend="\n";
        }
        else
        {
            prepend = "/* No conditional attributes found for this module/issueType */";
        }
        
        return new SimpleSkipFiltering(prepend+result);
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
private String createIssueChecker(RModuleAttribute rma, String setMarkerFunction, int indent) throws TorqueException, ScarabException
    {
        String result = "";
        boolean isRequired = rma.getRequired();
        if(!isRequired)
        {
            List<Condition> conditions = rma.getConditions();
                
            Iterator<Condition> iter = conditions.iterator();
            while(iter.hasNext())
            {
                Condition condition = iter.next();
                result += condition.createConditionCheckerScript(rma, setMarkerFunction, indent);
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public boolean isSealed() throws TorqueException
    {        
        boolean result = false;
        String status = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if (status != null)
        {
            String value = Environment.getConfigurationProperty("scarab.common.status.sealed", null);
            if(value != null)
            {
                AttributeValue attval = issue.getAttributeValue(status);
                if(attval != null && attval.getValue().equals(value))
                {
                    result = true;
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public boolean isOnHold() throws TorqueException
    {        
        boolean result = false;
        String status = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if (status != null)
        {
            String value = Environment.getConfigurationProperty("scarab.common.status.onhold", null);
            if(value != null)
            {
                AttributeValue attval = issue.getAttributeValue(status);
                if(attval != null && attval.getValue().equals(value))
                {
                    result = true;
                }
            }
        }
        return result;
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public boolean isActive() throws TorqueException
    {
        return !(isOnHold() || isSealed());
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public Attribute getStatusAttribute() throws TorqueException
    {
        Attribute attribute = null;
        String attributeName = Environment.getConfigurationProperty("scarab.common.status.id", null);
        if(attributeName != null)
        {
            attribute = issue.getAttribute(attributeName);
        }
        return attribute;
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public Attribute getOnHoldExpirationDate() throws TorqueException
    {
        Attribute attribute = null;
        String attributeName = Environment.getConfigurationProperty("scarab.common.status.onhold.dateProperty", null);
        if(attributeName != null)
        {
            attribute = issue.getAttribute(attributeName);
        }
        return attribute;
    }
            
// in java/org/tigris/scarab/workflow/IssueState.java
public Date getOnHoldUntil() throws TorqueException, ParseException
    {
        Date date = null;
        String attributeName = Environment.getConfigurationProperty("scarab.common.status.onhold.dateProperty", null);
        
        if (attributeName != null)
        {
            AttributeValue dateValue = issue.getAttributeValue(attributeName);
            if(dateValue!=null) 
            {
                String value = dateValue.getValue();
                if (value != null && value.length() > 0)
                {
                    date = DateAttribute.toDate(value);
                }
            }
        }
        return date;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
void doHandleDependencies()
        throws ScarabException, TorqueException
    {
        LOG.debug("Number of dependencies found: " + allDependencies.size());
        for (Iterator itr = allDependencies.iterator(); itr.hasNext();)
        {
            final Object[] data = (Object[])itr.next();
            final ActivitySet activitySetOM = (ActivitySet) data[0];
            final XmlActivity activity = (XmlActivity) data[1];
            

            final Dependency dependency = activity.getDependency();
            final String child = (String)issueXMLMap.get(dependency.getChild());
            final String parent = (String)issueXMLMap.get(dependency.getParent());
            if (parent == null || child == null)
            {
                if(null != parent || null != child)
                {
                    // add a comment into the issue that informs of the dependency
                    final Issue issueOM = IssueManager.getIssueById(null == parent ? child : parent);
                    final Attachment attachmentOM = new Attachment();
                    attachmentOM.setName("comment");
                    attachmentOM.setTypeId(Attachment.COMMENT__PK);
                    attachmentOM.setMimeType("text/plain");
                    // TODO i18n this
                    final String text = "Dependency \"" 
                            + parent + " (originally " + dependency.getParent() + ") " + dependency.getType() + ' ' 
                            + child + " (originally " + dependency.getParent()
                        + ") \" was not imported due to " 
                        + (null == parent ? dependency.getParent() : dependency.getChild()) + " not being resolved";
                    attachmentOM.setData(text);                    
                    issueOM.addComment(attachmentOM, ScarabUserManager.getInstance("Administrator"));
                }
                
                LOG.debug("Could not find issues: parent: " + parent + " child: " + child);
                LOG.debug("----------------------------------------------------");
                continue;
            }
            LOG.debug("doHandleDependencies: " + dependency);
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                LOG.error("[TODO] update-same-db import type not yet implemented");
                // trick here is that dependencies don't have ids or unique keys to find the 
                //  correct existing instance against.
            }
            else
            {
                try
                {
                    final String type = dependency.getType();
                    final Depend newDependOM = DependManager.getInstance();
                    final Issue parentIssueOM = IssueManager.getIssueById(parent);
                    final Issue childIssueOM = IssueManager.getIssueById(child);
                    newDependOM.setDefaultModule(parentIssueOM.getModule());
                    newDependOM.setObservedId(parentIssueOM.getIssueId());
                    newDependOM.setObserverId(childIssueOM.getIssueId());
                    newDependOM.setDependType(type);
                    LOG.debug("Dep: " + type + " Parent: " + parent + " Child: " + child);
                    LOG.debug("XML Activity id: " + activity.getId());
                    if (activity.isAddDependency())
                    {
                        parentIssueOM
                          .doAddDependency(activitySetOM, newDependOM, childIssueOM, null);
                        LOG.debug("Added Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isDeleteDependency())
                    {
                        parentIssueOM
                          .doDeleteDependency(activitySetOM, newDependOM, null);
                        LOG.debug("Deleted Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("----------------------------------------------------");
                    }
                    else if (activity.isUpdateDependency())
                    {
                        final Depend oldDependOM = parentIssueOM.getDependency(childIssueOM);
                        if (oldDependOM == null)
                        {
                            throw new IllegalArgumentException ("Whoops! Could not find the original dependency!"); //EXCEPTION
                        }
                        // we definitely know we are doing an update here.
                        newDependOM.setDeleted(false);
                        parentIssueOM
                          .doChangeDependencyType(activitySetOM, oldDependOM, newDependOM, null);
                        LOG.debug("Updated Dep Type: " + type + " Parent: " + parent + " Child: " + child);
                        LOG.debug("Old Type: " + oldDependOM.getDependType().getName() + " New type: " + newDependOM.getDependType().getName());
                        LOG.debug("----------------------------------------------------");
                    }
                }
                catch (Exception e)
                {
                    LOG.error("Failed to handle dependencies", e);
                    throw new ScarabException(new L10NKey("Failed to handle dependencies <localize me>"),e); //EXCEPTION
                }                
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueValidateEvent(final XmlModule module, 
            final XmlIssue issue)
        throws TorqueException
    {
        // Check for the existance of the module.
        Module moduleOM = null;
        try
        {
            moduleOM = getModuleForIssue(module,issue);
            if (moduleOM == null)
            {
                throw new IllegalArgumentException(); //EXCEPTION
            }

            // TODO: Handle user import.  Until then, ignore the
            // module's owner.
            //importUsers.add(module.getOwner());
        }
        catch (Exception e)
        {
            final Object[] args = (issue.hasModuleCode()
                ? new Object[]{null, issue.getModuleCode(), module.getDomain()}
                : new Object[]{module.getName(), module.getCode(), module.getDomain()});
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindModule", args);
            importErrors.add(error);
        }

        // Check for the existance of the issue type.
        IssueType issueTypeOM = null;
        try
        {
            issueTypeOM = IssueType.getInstance(issue.getArtifactType());
            if (issueTypeOM == null)
            {
                throw new IllegalArgumentException(); //EXCEPTION
            }
            if (!moduleOM.getRModuleIssueType(issueTypeOM).getActive())
            {
                final String error = Localization.format(
                    ScarabConstants.DEFAULT_BUNDLE_NAME,
                    getLocale(),
                    "IssueTypeInactive", issue.getArtifactType());
                importErrors.add(error);
            }
            List moduleAttributeList = null;
            if (moduleOM != null)
            {
                moduleAttributeList = moduleOM.getAttributes(issueTypeOM);
            }

            final List activitySets = issue.getActivitySets();
            for (Iterator itr = activitySets.iterator(); itr.hasNext();)
            {
                final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
                if (activitySet.getCreatedBy() != null)
                {
                    importUsers.add(activitySet.getCreatedBy());
                }
                if (activitySet.getAttachment() != null)
                {
                    final String attachCreatedBy = activitySet.getAttachment().getCreatedBy();
                    if (attachCreatedBy != null)
                    {
                        importUsers.add(attachCreatedBy);
                    }
                }

                // Validate the activity set's type.
                try
                {
                    final ActivitySetType ttOM =
                        ActivitySetTypeManager.getInstance(activitySet.getType());
                    if (ttOM == null)
                    {
                        throw new IllegalArgumentException(); //EXCEPTION
                    }
                }
                catch (Exception e)
                {
                    final String error = Localization.format(
                        ScarabConstants.DEFAULT_BUNDLE_NAME,
                        getLocale(),
                        "CouldNotFindActivitySetType", activitySet.getType());
                    importErrors.add(error);
                }

                // Validate the activity set's date.
                validateDate(activitySet.getCreatedDate(), true);

                final List activities = activitySet.getActivities();
                for (Iterator itrb = activities.iterator(); itrb.hasNext();)
                {
                    validateActivity(moduleOM, issueTypeOM, moduleAttributeList,
                                     activitySet, (XmlActivity) itrb.next());
                }
            }
        }
        catch (Exception e)
        {
            final String error = Localization.format(
                ScarabConstants.DEFAULT_BUNDLE_NAME,
                getLocale(),
                "CouldNotFindIssueType", issue.getArtifactType());
            importErrors.add(error);
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Issue createNewIssue(final XmlModule module, final XmlIssue issue, final String id)
        throws TorqueException,ScarabException
    {
        // get the instance of the module
        final Module moduleOM = getModuleForIssue(module,issue);
        // get the instance of the issue type
        final IssueType issueTypeOM = IssueType.getInstance(issue.getArtifactType());
        issueTypeOM.setName(issue.getArtifactType());
        // get me a new issue since we couldn't find one before
        final Issue issueOM = Issue.getNewInstance(moduleOM, issueTypeOM);

        // The import data may nominate its ID
        if (id != null) {
            // This will cause Issue.save() to use this ID
            issueOM.setFederatedId(id);
        }
        // create the issue in the database

        // Add the mapping between the issue id and the id that was created.
        // This mapping is used dependency checking and printing out in 
        // results list of original id and new id. The original issue id can be
        // null. In this case, have the original id show as 'null (index)'
        // where index is count into the issueXMLMap. We add the index to keep
        // the key unique. This substitute original id also shouldn't interfere
        // w/ issueXMLMap's use dependency checking.
        String issueID = "Null (" + Integer.toString(issueXMLMap.size()) + ")";
        if(issue.getId() != null)
        {
            issueID = (issue.hasModuleCode()?"":module.getCode())
                + issue.getId();
        }
        issueXMLMap.put(issueID, issueOM.getUniqueId());

        LOG.debug("Created new Issue: " + issueOM.getUniqueId());
        return issueOM;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private void doIssueEvent(final XmlModule module, final XmlIssue issue)
        throws TorqueException,ScarabException,ParseException
    {
/////////////////////////////////////////////////////////////////////////////////  
        // Get me an issue
        Issue issueOM = null;
        final String issueID = (issue.hasModuleCode() ? "" : module.getCode()) + issue.getId();
        if (getImportTypeCode() == CREATE_SAME_DB || getImportTypeCode() == CREATE_DIFFERENT_DB)
        {
            // Check if the new issue nominates an ID and if the database does
            // not already contain an issue with that ID
            if (issue.getId() != null && IssueManager.getIssueById(issueID) == null)
            {
                // Create the new issue with the nominated ID
                issueOM = createNewIssue(module, issue, issue.getId());
            }
            else
            {
                // Crate the new issue with an automatically allocated ID
                issueOM = createNewIssue(module, issue, null);
            }
        }
        else if (getImportTypeCode() == UPDATE_SAME_DB) // nice to specify just for searching/refactoring
        {
            issueOM = IssueManager.getIssueById(issueID);
            
            if (issueOM == null)
            {
                issueOM = createNewIssue(module, issue, null);
            }
            else
            {
                LOG.debug("Found Issue in db: " + issueOM.getUniqueId());
            }
        }

/////////////////////////////////////////////////////////////////////////////////  

        // Loop over the XML activitySets
        final List activitySets = issue.getActivitySets();
        LOG.debug("-----------------------------------");
        LOG.debug("Number of ActivitySets in Issue: " + activitySets.size());
        for (Iterator itr = activitySets.iterator(); itr.hasNext();)
        {
            final XmlActivitySet activitySet = (XmlActivitySet) itr.next();
            LOG.debug("Processing ActivitySet: " + activitySet.getId());

/////////////////////////////////////////////////////////////////////////////////  
            // Deal with the attachment for the activitySet
            final XmlAttachment activitySetAttachment = activitySet.getAttachment();
            Attachment activitySetAttachmentOM = null;
            if (activitySetAttachment != null)
            {
                if (getImportTypeCode() == UPDATE_SAME_DB)
                {
                    try
                    {
                        activitySetAttachmentOM = AttachmentManager
                            .getInstance(activitySetAttachment.getId());
                        LOG.debug("Found existing ActivitySet Attachment");
                    }
                    catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
                }
                else
                {
                    activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    LOG.debug("Created ActivitySet Attachment object");
                }
            }
            else
            {
                LOG.debug("OK- No Attachment in this ActivitySet");
            }

/////////////////////////////////////////////////////////////////////////////////  
            // Attempt to get the activitySet OM
            boolean alreadyCreated = false;
            ActivitySet activitySetOM = null;
            if (getImportTypeCode() == UPDATE_SAME_DB)
            {
                try
                {
                    activitySetOM = ActivitySetManager.getInstance(activitySet.getId());
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in db: " + activitySetOM.getActivitySetId());
                }
                catch (Exception e)
                {
                    activitySetOM = ActivitySetManager.getInstance();
                }
            }
            else
            {
                // first try to get the ActivitySet from the internal map
                if (activitySetIdMap.containsKey(activitySet.getId()))
                {
                    activitySetOM = ActivitySetManager.getInstance(
                        (String)activitySetIdMap.get(activitySet.getId()));
                    alreadyCreated = true;
                    LOG.debug("Found ActivitySet: " + activitySet.getId() + 
                              " in map: " + activitySetOM.getActivitySetId());
                }
                else // it hasn't been encountered previously
                {
                    activitySetOM = ActivitySetManager.getInstance();
                    LOG.debug("Created new ActivitySet");
                }
            }

            final ScarabUser activitySetCreatedByOM = findUser(activitySet.getCreatedBy());
            
            if (LOG.isDebugEnabled())
            {
                LOG.debug("ActivitySet: " + activitySet.getId() + "; of type: " + activitySet.getType() + "; by: " + activitySet.getCreatedBy());
                LOG.debug("   alreadyCreated: " + alreadyCreated);
            }
            
            if (!alreadyCreated)
            {
                // Populate the ActivitySet
                // Get the ActivitySet type/createdby values (we know these are valid)
                final ActivitySetType ttOM = ActivitySetTypeManager.getInstance(activitySet.getType());
                activitySetOM.setActivitySetType(ttOM);
                if( activitySetCreatedByOM != null ){
                    activitySetOM.setCreatedBy(activitySetCreatedByOM.getUserId());
                }
                else
                {
                	// Anonymous user. better than nothing.
                	try {
						activitySetOM.setCreatedBy(ScarabUserManager.getAnonymousUser().getUserId());
					} catch (Exception e) {
						LOG.error("doIssueEvent: Cannot get Anonymous user: e");
					}
                }
                activitySetOM.setCreatedDate(activitySet.getCreatedDate().getDate());
                if (activitySetAttachmentOM != null)
                {
                    activitySetAttachmentOM.save();
                    activitySetOM.setAttachment(activitySetAttachmentOM);
                }
                activitySetOM.save();
                if( activitySet.getId() != null){
                    // if id is valid, save for later re-use.
                    activitySetIdMap.put(activitySet.getId(), 
                                         activitySetOM.getPrimaryKey().toString());
                }
            }

            // Determine if this ActivitySet should be marked as the 
            // creation event
            final ActivitySet creationSet = issueOM.getActivitySetRelatedByCreatedTransId();
            if (ActivitySetTypePeer.CREATE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) 
               ||
               (ActivitySetTypePeer.MOVE_ISSUE__PK
                .equals(activitySetOM.getTypeId()) && 
                        (creationSet == null || activitySetOM.getCreatedDate()
                         .before(creationSet.getCreatedDate()))) ) 
            {
                issueOM.setActivitySetRelatedByCreatedTransId(activitySetOM);
                issueOM.save();
            }

/////////////////////////////////////////////////////////////////////////////////  
// Deal with changing user attributes. this code needs to be in this *strange*
// location because we look at the entire activityset in order to determine
// that this is a change user activity set. of course in the future, it would
// be really nice to create an activityset/activiy type that more accurately 
// reflects what type of change this is. so that it is easier to case for. for
// now, we just look at some fingerprints to determine this information. -JSS

            if (activitySet.isChangeUserAttribute())
            {
                final List activities = activitySet.getActivities();
                final XmlActivity activityA = (XmlActivity)activities.get(0);
                final XmlActivity activityB = (XmlActivity)activities.get(1);
                
                final ScarabUser assigneeOM = findUser(activityA.getOldUser());
                final ScarabUser assignerOM = findUser(activityB.getNewUser());

                final Attribute oldAttributeOM = Attribute.getInstance(activityA.getAttribute());

                final AttributeValue oldAttValOM = issueOM.getUserAttributeValue(assigneeOM, oldAttributeOM);
                if (oldAttValOM == null)
                {
                    LOG.error("User '" + assigneeOM.getName() + "' was not previously '" + oldAttributeOM.getName() + "' to the issue!");
                }

                // Get the Attribute associated with the new Activity
                final Attribute newAttributeOM = Attribute.getInstance(activityB.getAttribute());

                issueOM.changeUserAttributeValue(activitySetOM,
                            assigneeOM, 
                            assignerOM, 
                            oldAttValOM,
                            newAttributeOM, null);
                LOG.debug("-------------Updated User AttributeValue------------");
                continue;
            }

/////////////////////////////////////////////////////////////////////////////////  

            // Deal with the activities in the activitySet
            final List activities = activitySet.getActivities();
            LOG.debug("Number of Activities in ActivitySet: " + activities.size());

            final LinkedMap avMap = issueOM.getModuleAttributeValuesMap();
            LOG.debug("Total Module Attribute Values: " + avMap.size());
            for (Iterator itrb = activities.iterator(); itrb.hasNext();)
            {
                final XmlActivity activity = (XmlActivity) itrb.next();
                LOG.debug("Looking at activity id: " + activity.getId());

                // Get the Attribute associated with the Activity
                final Attribute attributeOM = Attribute.getInstance(activity.getAttribute());

                // deal with the activity attachment (if there is one)
                final XmlAttachment activityAttachment = activity.getAttachment();
                Attachment activityAttachmentOM = null;
                if (activityAttachment != null)
                {
                    // look for an existing attachment in the activity
                    // the case is when we have a URL and we create it
                    // and then delete it, the attachment id is still the
                    // same so there is no reason to re-create the attachment
                    // again.
                    final String previousXmlId = activityAttachment.getId();
                    final String previousId = (String)attachmentIdMap.get(previousXmlId);
                    if (previousId == null) 
                    {
                        activityAttachmentOM = createAttachment(issueOM, activityAttachment);
                        activityAttachmentOM.save();
                        attachmentIdMap.put(previousXmlId, activityAttachmentOM.getPrimaryKey().toString());
                        
                        // Special case. After the Attachment object has been 
                        // saved, if the ReconcilePath == true, then assume 
                        // that the fileName is an absolute path to a file and
                        // copy it to the right directory
                        // structure under Scarab's path.
                        if (allowFileAttachments && activityAttachment.getReconcilePath())
                        {
                            try
                            {
                                activityAttachmentOM
                                    .copyFileFromTo(activityAttachment.getFilename(), 
                                                    activityAttachmentOM.getFullPath());
                            } 
                            catch (FileNotFoundException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotFindFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            } 
                            catch (IOException ex)
                            {
                                // FIXME correct error message "ExceptionCouldNotReadFile"
                                throw new ScarabException(L10NKeySet.ExceptionGeneral,ex);
                            }
                        }
                        LOG.debug("Created Activity Attachment object");
                    }
                    else 
                    {
                        activityAttachmentOM = AttachmentManager
                            .getInstance(previousId);
                        LOG.debug("Found existing Activity Attachment");
                    }
                }
                else
                {
                    LOG.debug("OK- No Attachment in this Activity");
                }

                // deal with null attributes (need to do this before we create the 
                // activity right below because this will create its own activity).
                if (attributeOM.equals(nullAttribute))
                {
                    // add any dependency activities to a list for later processing
                    if (isDependencyActivity(activity))
                    {
                        if (!isDuplicateDependency(activity))
                        {
                            final Object[] obj = {activitySetOM, activity, activityAttachmentOM};
                            allDependencies.add(obj);
                            dependActivitySetId.add(activity.getDependency());
                            LOG.debug("-------------Stored Dependency # " 
                                    + allDependencies.size() + '[' + activity.getDependency() + ']');
                            continue;
                        }
                    }
                    else
                    {
                        // create the activity record.
                        ActivityManager.createTextActivity(issueOM, nullAttribute, activitySetOM, 
                                    ActivityType.getActivityType(activity.getActivityType()), activity.getDescription(), activityAttachmentOM, 
                                    activity.getOldValue(), activity.getNewValue());
        
                        LOG.debug("-------------Saved Null Attribute-------------");
                        continue;
                    }
                }

                // create the activityOM
                createActivity(activity, module, 
                                            issueOM, attributeOM, activitySetOM);

                // check to see if this is a new activity or an update activity
                AttributeValue avalOM = null;
                for (Iterator moduleAttributeValueItr = avMap.mapIterator(); 
                     moduleAttributeValueItr.hasNext() && avalOM == null;)
                {
                    final AttributeValue testAvalOM = (AttributeValue)
                        avMap.get(moduleAttributeValueItr.next());
                    final Attribute avalAttributeOM = testAvalOM.getAttribute();

                    LOG.debug("Checking Attribute match: " + avalAttributeOM.getName() + 
                              " against: " + attributeOM.getName());
                    if (avalAttributeOM.equals(attributeOM))
                    {
                        avalOM = testAvalOM;
                    }
                }

                if (avalOM != null) 
                {
                    final Attribute avalAttributeOM = avalOM.getAttribute();
                    LOG.debug("Attributes match!");
                    AttributeValue avalOM2 = null;
                    if (!activity.isNewActivity())
                    {
                        LOG.debug("Activity is not new.");
                        avalOM2 = AttributeValue.getNewInstance(
                            avalAttributeOM.getAttributeId(), 
                            avalOM.getIssue());
                        avalOM2.setProperties(avalOM);
                    }

                    if (avalAttributeOM.isOptionAttribute())
                    {
                        LOG.debug("We have an Option Attribute: " + 
                                  avalAttributeOM.getName());
                        final AttributeOption newAttributeOptionOM = 
                                AttributeOptionManager.getInstance(
                                         attributeOM, activity.getNewOption(),
                                         issueOM.getModule(),
                                         issueOM.getIssueType());
                        if (activity.isNewActivity())
                        {
                            if (newAttributeOptionOM != null)
                            {
                                avalOM.setOptionId(newAttributeOptionOM.getOptionId());
                                avalOM.startActivitySet(activitySetOM);
                                avalOM.setAttribute(attributeOM);
                                avalOM.save();
                                LOG.debug("-------------Saved Attribute Value-------------");
                            }
                            else
                            {
                                LOG.warn("NewAttributeOptionOM is null for " +
                                         activity.getNewOption());
                            }
                        }
                        else if(newAttributeOptionOM != null)
                        {
                            avalOM2.setOptionId(newAttributeOptionOM.getOptionId());
                            final HashMap map = new HashMap();
                            map.put(avalOM.getAttributeId(), avalOM2);
                            issueOM.setAttributeValues(activitySetOM, map, null, activitySetCreatedByOM);
                            LOG.debug("-------------Saved Option Attribute Change-------------");
                        }
                    }
                    else if (avalAttributeOM.isUserAttribute())
                    {
                        LOG.debug("We have a User Attribute: " 
                                  + avalAttributeOM.getName());
                        if (activity.isNewActivity())
                        {
                            // Don't need to pass in the attachment because
                            // it is already in the activitySetOM.
                            // If we can't get an assignee new-user, then 
                            // use the activity set creator as assignee.
                            ScarabUser assigneeOM = findUser(activity.getNewUser());
                            assigneeOM = (assigneeOM != null)
                                ? assigneeOM: activitySetCreatedByOM;
                            if( assigneeOM != null ){
                                issueOM.assignUser(activitySetOM, 
                                    assigneeOM, null, avalAttributeOM, null);
                            }
                            LOG.debug("-------------Saved User Assign-------------");
                        }
                        else if (activity.isRemoveUserActivity())
                        {
                            // remove a user activity
                            final ScarabUser oldUserOM = findUser(activity.getOldUser());
                            // need to reset the aval because the current one
                            // is marked as new for some reason which causes an
                            // insert and that isn't the right behavior here 
                            // (we want an update)
                            avalOM = null;
                            for (Iterator i = issueOM.getAttributeValues(
                                 avalAttributeOM).iterator(); 
                                 i.hasNext() && avalOM == null;) 
                            {
                                final AttributeValue av = (AttributeValue)i.next();
                                if (oldUserOM.getUserId().equals(av.getUserId())) 
                                {
                                    avalOM = av;
                                }
                            }

                            if (avalOM == null) 
                            {
                                if (LOG.isDebugEnabled()) 
                                {
                                    LOG.debug("Could not find previous AttributeValue assigning " +
                                        (oldUserOM == null ? "NULL" : 
                                        oldUserOM.getUserName()) + 
                                        " to attribute " + 
                                              avalAttributeOM.getName());
                                }                                
                            }
                            else 
                            {
                                // don't need to pass in the attachment because
                                // it is already in the activitySetOM
                                issueOM.deleteUser(activitySetOM, oldUserOM, 
                                    activitySetCreatedByOM, avalOM, null);
                                LOG.debug("-------------Saved User Remove-------------");
                            }
                        }
                    }
                    else if (avalAttributeOM.isTextAttribute() || avalAttributeOM.isIntegerAttribute())
                    {
                        LOG.debug("We have a Text Attribute: " + avalAttributeOM.getName());

                        avalOM.startActivitySet(activitySetOM);
                        avalOM.setAttribute(attributeOM);

                        if (activity.isNewActivity())
                        {
                            avalOM.setValue(activity.getNewValue());
                        }
                        else if (!activity.getNewValue()
                                .equals(avalOM.getValue()))
                        {
                            avalOM2.setValue(activity.getNewValue());
                            avalOM.setProperties(avalOM2);
                        }
                        
                        avalOM.save();
                        LOG.debug("-------------Saved Attribute Value-------------");
                    }
                }
                issueOM.save();
                LOG.debug("-------------Saved Issue-------------");
            }
        }
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Activity createActivity(final XmlActivity activity,  
                                         final XmlModule module,
                                         final Issue issueOM, 
                                         final Attribute attributeOM,
                                         final ActivitySet activitySetOM)
        throws TorqueException, ParseException, ScarabException
    {
        Activity activityOM = null;
        if (getImportTypeCode() == UPDATE_SAME_DB)
        {
            try
            {
                activityOM = ActivityManager.getInstance(activity.getId());
            }
            catch (Exception e)
            {
                activityOM = ActivityManager.getInstance();
            }
        }
        else
        {
            activityOM = ActivityManager.getInstance();
        }

        activityOM.setIssue(issueOM);
        activityOM.setAttribute(attributeOM);
        activityOM.setActivityType(ActivityType.OTHER.getCode());
        activityOM.setActivitySet(activitySetOM);
        if (activity.getEndDate() != null)
        {
            activityOM.setEndDate(activity.getEndDate().getDate());
        }

        // Set the attachment for the activity
        Attachment newAttachmentOM = null;
        if (activity.getAttachment() != null)
        {
            newAttachmentOM = createAttachment(issueOM, activity.getAttachment());
            newAttachmentOM.save();
            activityOM.setAttachment(newAttachmentOM);
        }

        LOG.debug("Created New Activity");
        return activityOM;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Attachment createAttachment(final Issue issueOM, 
            final XmlAttachment attachment)
        throws TorqueException, ScarabException, ParseException
    {
        final Attachment attachmentOM = AttachmentManager.getInstance();
        attachmentOM.setIssue(issueOM);
        final AttachmentType type = AttachmentType.getInstance(attachment.getType());
        if (allowFileAttachments || !Attachment.FILE__PK.equals(type.getAttachmentTypeId())) 
        {
            attachmentOM.setName(attachment.getName());
            attachmentOM.setAttachmentType(type);
            attachmentOM.setMimeType(null != attachment.getMimetype()
                    ? attachment.getMimetype()
                    : ComponentLocator.getMimeTypeService().getContentType(attachment.getFilename(), null));
            attachmentOM.setFileName(attachment.getFilename());        
            attachmentOM.setData(attachment.getData());
        }
        else 
        {
            // add a comment that the file will not be imported.  An alternative would be
            // to skip the activity altogether, but we will then need to check that there 
            // are other activities or we need to completely ignore the ActivitySet
            attachmentOM.setName("comment");
            attachmentOM.setTypeId(Attachment.COMMENT__PK);
            attachmentOM.setMimeType("text/plain");
            String text = "File, " + attachment.getFilename() + 
                ", was not imported. The old description follows:\n\n" + attachment.getName();
            final String data = attachment.getData();  // this should be null, but just in case
            if (data != null) 
            {
                text += "\n\n" + data;
            }
            attachmentOM.setData(text);
        }
        
        attachmentOM.setCreatedDate(attachment.getCreatedDate().getDate());
        final ModifiedDate modifiedDate = attachment.getModifiedDate();
        if (modifiedDate != null)
        {
            attachmentOM.setModifiedDate(modifiedDate.getDate());
        }
        final ScarabUser creUser = findUser(attachment.getCreatedBy());
        if (creUser != null)
        {
            attachmentOM.setCreatedBy(creUser.getUserId());
        }

        final String modifiedBy = attachment.getModifiedBy();
        if (modifiedBy != null)
        {
            final ScarabUser modUserOM = findUser(attachment.getModifiedBy());
            if (modUserOM != null)
            {
                attachmentOM.setModifiedBy(modUserOM.getUserId());
            }
        }

        attachmentOM.setDeleted(attachment.getDeleted());
        return attachmentOM;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private ScarabUser findUser(final String userStr) 
        throws TorqueException,ScarabException
    {
        
        ScarabUser user = ScarabUserManager.getInstance(userStr);
        if (user == null && userStr != null && userStr.indexOf("@") <0 )
        {
            LOG.debug("user specified possibly by email address: "+userStr);
            // maybe it's an email not a username
            user = ScarabUserManager.getInstanceByEmail(userStr);
            LOG.debug("found "+user);
        }
        return user;        
    }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
private Module getModuleForIssue(final XmlModule module, final XmlIssue issue)
        throws TorqueException, ScarabException
    {
        
        if(issue.hasModuleCode() && !issue.getModuleCode().equals(module.getCode()) && !allowGlobalImport){
            throw new ScarabException(
                    new L10NKey("Lacking permission to cross-module import. Contact your administor. <localize me>"));
        }
        
        return issue.hasModuleCode()
                ? ModuleManager.getInstance(module.getDomain(),
                                            null,issue.getModuleCode())
                : ModuleManager.getInstance(module.getDomain(),
                                            module.getName(), module.getCode());
     }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
protected ScarabIssues insert(
            final String name, 
            final Reader is, 
            final BeanReader reader)
        throws ParserConfigurationException,SAXException,IOException,ScarabException, TorqueException
    {
        setValidationMode(reader, false);
        final ScarabIssues si = (ScarabIssues)reader.parse(is);
        si.doHandleDependencies();
        LOG.debug("Successfully imported " + name + '!');
        return si;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader getScarabFormattedReader(
            final Object input,
            final ImportType type,
            final Module currModule) throws IOException, TransformerException, TorqueException, JDOMException 
    {
        Reader returnValue = null;
        
        if( SCARAB == type )
        {
            // is in correct format already, just return the input stream
            returnValue = readerFor(input);
        }
        else if( BUGZILLA == type )
        {
            // Location of the extensions directory for Bugzilla
            // Transform configuration, mappings and attachments are here
            // TODO move onto resourceDirectory derivative
            final String extensions = System.getProperty("catalina.home") + "/../extensions/bugzilla";
            
            // Locate the Bugzilla to Scarab XSL transform
            final InputStream xsl = getClass().getResourceAsStream(BUGZILLA_XSL);
            
            // Transform Bugzilla xml to scarab format
            // (Trailing '/' to resources is deliberate)
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, extensions);
            
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        else if( JIRA == type )
        {
                    
            // transform xml to scarab format
            final InputStream xsl = getClass().getResourceAsStream(JIRA_XSL);
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, resourceDirectory);
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        return returnValue;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader insertModuleNode(final Reader result, 
            final Module currModule) 
        throws TorqueException, JDOMException, IOException, TransformerException 
    {
        
        final ScarabUser user = ScarabUserManager.getInstance(currModule.getOwnerId());        
        
        // Core Java: org.w3c.dom version (jdk1.4+ compatible)
//        final DocumentBuilder docBuilder = documentBuilderFactory.newDocumentBuilder();
//        final Document doc = docBuilder.parse( new InputSource(result) );
//        // insert module
//        final Element root = doc.getDocumentElement();
//        final Element moduleNode = doc.createElement("module");
//        final Element idNode = doc.createElement("id");
//        final Element parentIdNode = doc.createElement("parent-id");
//        final Element nameNode = doc.createElement("name");
//        final Element ownerNode = doc.createElement("owner");
//        final Element descriptionNode = doc.createElement("description");
//        final Element urlNode = doc.createElement("url");
//        final Element domainNode = doc.createElement("domain");
//        final Element codeNode = doc.createElement("code");
//        
//        idNode.appendChild(doc.createTextNode(String.valueOf(currModule.getModuleId())));
//        parentIdNode.appendChild(doc.createTextNode(String.valueOf(currModule.getParentId())));
//        nameNode.appendChild(doc.createTextNode(currModule.getName()));
//        ownerNode.appendChild(doc.createTextNode(user.getUserName()));
//        descriptionNode.appendChild(doc.createTextNode(currModule.getDescription()));
//        urlNode.appendChild(doc.createTextNode(currModule.getUrl()));
//        domainNode.appendChild(doc.createTextNode(currModule.getHttpDomain()));
//        codeNode.appendChild(doc.createTextNode(currModule.getCode()));
//        
//        moduleNode.appendChild(idNode);
//        moduleNode.appendChild(parentIdNode);
//        moduleNode.appendChild(nameNode);
//        moduleNode.appendChild(ownerNode);
//        moduleNode.appendChild(descriptionNode);
//        moduleNode.appendChild(urlNode);
//        moduleNode.appendChild(domainNode);
//        moduleNode.appendChild(codeNode);
//        
//        root.appendChild(moduleNode);
        
        // JDom version (jdk1.3 compatible)
        
        final SAXBuilder builder = new SAXBuilder();
        builder.setEntityResolver(new EntityResolver()
        {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }   
        });
        final Document doc = builder.build(result);        
        final Element root = doc.getRootElement();

        final Element moduleNode = new Element("module");
        final Element idNode = new Element("id");
        final Element parentIdNode = new Element("parent-id");
        final Element nameNode = new Element("name");
        final Element ownerNode = new Element("owner");
        final Element descriptionNode = new Element("description");
        final Element urlNode = new Element("url");
        final Element domainNode = new Element("domain");
        final Element codeNode = new Element("code");    
        
        idNode.setText(String.valueOf(currModule.getModuleId()));
        parentIdNode.setText(String.valueOf(currModule.getParentId()));
        nameNode.setText(currModule.getRealName());
        ownerNode.setText(user.getUserName());
        descriptionNode.setText(currModule.getDescription());
        urlNode.setText(currModule.getUrl());
        domainNode.setText(currModule.getHttpDomain());
        codeNode.setText(currModule.getCode());
        
        moduleNode.addContent(idNode)
                .addContent(parentIdNode)
                .addContent(nameNode)
                .addContent(ownerNode)
                .addContent(descriptionNode)
                /*
                 * These are excluded for now, since your database domain may 
                 * not correspond to currModule.getHttpDomain().
                .addContent(urlNode)
                .addContent(domainNode)
                 */
                .addContent(codeNode);
        root.addContent(2,moduleNode);
        
        return transformXML(new JDOMSource(doc), null, currModule, null);
    }
            
// in java/org/tigris/scarab/util/IssueIdParser.java
public static List getIssueIdTokens(Module module, String text)
        throws TorqueException
    {
        List result = new ArrayList();
        RE re = new RE(module.getIssueRegex());
        re.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
        int pos = 0;
        while (re.match(text, pos))
        {
            Log.get().debug(re.getParen(0) + " found at " + re.getParenStart(0));
            result.add(re.getParen(0));
            pos = re.getParenEnd(0);
        }

        return result;
    }
            
// in java/org/tigris/scarab/util/IssueIdParser.java
public static List tokenizeText(Module module, String text)
        throws TorqueException
    {
        List result = new ArrayList();
        RE re = new RE(module.getIssueRegex());
        re.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
        int pos = 0;
        while (re.match(text, pos))
        {
            Log.get().debug(re.getParen(0) + " found at " + re.getParenStart(0));
            // Add any text that did not contain an id
            if (re.getParenStart(0) > pos) 
            {
                result.add(text.substring(pos, re.getParenStart(0))); 
            }
                
            String token = re.getParen(0);
            String id = getIssueIdFromToken(module, token);
            if (id == null)
            {
                result.add(token);
            }
            else 
            {
                List tokenId = new ArrayList(2);
                tokenId.add(token);
                tokenId.add(id);
                result.add(tokenId);
            }
            
            pos = re.getParenEnd(0);
        }

        if (pos < text.length()) 
        {
            result.add(text.substring(pos));
        }
            
        return result;
    }
            
// in java/org/tigris/scarab/util/IssueIdParser.java
public static Map getIssueIds(Module module, String text)
        throws TorqueException
    {
        List tokens = getIssueIdTokens(module, text);
        Map idMap = new HashMap(presizeMap(tokens.size()));
        Iterator i = tokens.iterator();
        while (i.hasNext()) 
        {
            String token = (String)i.next();
            String id = getIssueIdFromToken(module, token);
            if (id != null) 
            {
                idMap.put(token, id);
            }
        }
        return idMap;
    }
            
// in java/org/tigris/scarab/util/word/QueryResult.java
public final Issue getIssue()
        throws TorqueException
        {
    	return IssueManager.getInstance(issueId);
    }
            
// in java/org/tigris/scarab/util/word/QueryResult.java
public final String getUniqueId()
        throws TorqueException
    {
        return getIssue().getUniqueId();
    }
            
// in java/org/tigris/scarab/util/word/QueryResult.java
public final List getAttributeValues()
        throws TorqueException
    {
        if(attributeValues==null)
        {
            attributeValues = new ArrayList();
            for(int j=0;j<issueListAttributeColumns.size();j++)
            {
                RModuleUserAttribute rmua = (RModuleUserAttribute)issueListAttributeColumns.get(j);

                List value = null;
                if(rmua.isInternal())
                {
                	String attributeId = rmua.getInternalAttribute();
                    value = getInternalAttributeValue(attributeId);
                }
                else
                {
                    Integer attributeId = rmua.getAttributeId();                
                    value = getAttributeValue(attributeId);
                }                    
                attributeValues.add(value);
            }                                
        }        
        return attributeValues;
    }
            
// in java/org/tigris/scarab/util/word/QueryResult.java
private List getAttributeValue(Integer attributeId)
        throws TorqueException
	{
        List value = new ArrayList();
        List attributeValue = getIssue().getAttributeValues(attributeId);
        String singleValue = null;
        
        if(attributeId.equals(sortAttrId))
	    {
	    	if(sortValueId!=null)
	    	{
	    		AttributeValue sortValue = AttributeValueManager.getInstance(sortValueId);
	    		singleValue = sortValue.getDisplayValue(L10N);	    		
	    	}
	    	else
	    	{
	    		singleValue = "";
	    	}
        	value.add(singleValue);
	    }
	    else
	    {
            for(int i=0;i<attributeValue.size();i++)
		    {
		        singleValue = ((AttributeValue)attributeValue.get(i)).getDisplayValue(L10N);
		        value.add( singleValue );
		    }
		}
		return value;
	}
            
// in java/org/tigris/scarab/util/word/QueryResult.java
private List getInternalAttributeValue(String attributeId)
        throws TorqueException
	{
        List value = new ArrayList();
        if (attributeId.equals(RModuleUserAttribute.CREATED_BY.getName()))
        {
            ScarabUser user = getIssue().getCreatedBy();
            value.add(user.getUserName());
        }
        else if (attributeId.equals(RModuleUserAttribute.CREATED_DATE.getName()))
        {
            DateFormat df = new SimpleDateFormat(L10NKeySet.ShortDatePattern.getMessage(L10N));
            value.add(df.format(getIssue().getCreatedDate()));
        }
        else if (attributeId.equals(RModuleUserAttribute.MODIFIED_BY.getName()))
        {
            ScarabUser user = getIssue().getModifiedBy();
            value.add(user.getUserName());
        }
        else if (attributeId.equals(RModuleUserAttribute.MODIFIED_DATE.getName()))
        {
            DateFormat df = new SimpleDateFormat(L10NKeySet.ShortDatePattern.getMessage(L10N));
            value.add(df.format(getIssue().getModifiedDate()));
        }
        else if (attributeId.equals(RModuleUserAttribute.MODULE.getName()))
        {
            value.add(getIssue().getModule().getRealName());
        }
        else if (attributeId.equals(RModuleUserAttribute.ISSUE_TYPE.getName()))
        {
            IssueType isueType = getIssue().getIssueType();
            value.add(isueType.getDisplayName(getIssue().getModule()));
        }
		return value;
	}
            
// in java/org/tigris/scarab/util/word/QueryResult.java
public final List getAttributeValuesAsCSV()
        throws TorqueException
    {
        List result = null;
        if (getAttributeValues() != null) 
        {
            result = new ArrayList(getAttributeValues().size());
            for (Iterator i = getAttributeValues().iterator(); i.hasNext();) 
            {
                List multiVal = (List)i.next();
                String csv = StringUtils.join(multiVal.iterator(), ", ");
                if(csv.indexOf('\n') > -1)
                {
                    csv = csv.replace('\n', '.');
                }
                if(csv.indexOf('\r') > -1)
                {
                    csv = csv.replace('\r', '.');
                }
                result.add(csv);
            }
        }            
        return result;
    }
            
// in java/org/tigris/scarab/util/word/LuceneSearchIndex.java
private Document document(Issue issue)
            throws TorqueException
    {
        String issueId = issue.getIssueId().toString();
        Document doc = new Document();
        doc.add(new Field( ISSUE_ID, issueId, Field.Store.YES, Field.Index.UN_TOKENIZED ));

        for(Iterator as = issue.getAttachments().iterator(); as.hasNext();)
        {
            Attachment a = (Attachment)as.next();
            if (    a.getTypeId().equals(AttachmentTypePeer.COMMENT_PK)
                && !a.getDeleted()) 
            {
                doc.add(new Field( COMMENT, a.getData(), Field.Store.YES, Field.Index.TOKENIZED ));                
            }
        }
        
        for(Iterator vs = issue.getAttributeValuesMap().values().iterator(); vs.hasNext();)
        {
            AttributeValue v = (AttributeValue)vs.next();
            if(    v instanceof StringAttribute
               && !v.getDeleted())
            {
                doc.add(new Field( ATTRIBUTE_ID + v.getAttributeId().toString(), v.getValue(), Field.Store.YES, Field.Index.TOKENIZED ));
            }
        }
        return doc;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public static ScarabUser getSearchingUserPlaceholder()
        throws TorqueException
    {
        if(searchingUserPlaceholder==null)
        {
            searchingUserPlaceholder = ScarabUserManager.getInstance();
            searchingUserPlaceholder.setFirstName("");
            searchingUserPlaceholder.setLastName(SEARCHING_USER_KEY);
            searchingUserPlaceholder.setUserName(SEARCHING_USER_KEY);
            searchingUserPlaceholder.setEmail("");
        }
        return searchingUserPlaceholder;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addMITCriteria(Criteria crit)
        throws org.apache.torque.TorqueException
    {   
        mitList.addToCriteria(crit);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void setupSortColumn(Criteria crit, Integer sortAttrId)
        throws TorqueException
    {           
        crit.addAlias(SORT_TABLE, AttributeValuePeer.TABLE_NAME);

        joinAttributeValue(crit, SORT_TABLE, sortAttrId, Criteria.LEFT_JOIN);

        crit.addSelectColumn(useAlias(SORT_TABLE, AttributeValuePeer.VALUE_ID));

        String sortColumn;
        Attribute att = AttributeManager.getInstance(sortAttrId); 

        if (att.isOptionAttribute())
        {
            crit.addJoin(
                IssuePeer.MODULE_ID, 
                RModuleOptionPeer.MODULE_ID
                + ( " AND " 
                +  IssuePeer.TYPE_ID + " = " + RModuleOptionPeer.ISSUE_TYPE_ID +
                " AND " + RModuleOptionPeer.OPTION_ID + " = " + useAlias(SORT_TABLE, AttributeValuePeer.OPTION_ID)
                ).replace('.', DOT_REPLACEMENT_IN_JOIN_CONDITION ), 
                Criteria.LEFT_JOIN
            );
            sortColumn = RModuleOptionPeer.PREFERRED_ORDER;
        }
        else 
        {
            sortColumn = useAlias(SORT_TABLE, AttributeValuePeer.VALUE);
        }
        
        addSortColumn(crit, sortColumn);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
private void addSortCriteria(Criteria crit)
        throws org.apache.torque.TorqueException
    {
        Integer sortAttrId = getSortAttributeId();
        String sortInternal = getSortInternalAttribute();
        
        if (sortAttrId != null) 
        {
            setupSortColumn(crit, sortAttrId);
        }
        else if (sortInternal != null)
        {
            setupInternalSortColumn(crit, sortInternal);
        }
        else
        {
        	addSortColumn(crit, IssuePeer.ISSUE_ID);
        }
        crit.addAscendingOrderByColumn(IssuePeer.ISSUE_ID);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public void addAttributeValue(Attribute attribute, String value)
    	throws TorqueException
    {
        AttributeValue av = AttributeValue.getNewInstance(attribute,searchIssue);
        av.setValue(value);
        searchIssue.addAttributeValue(av);
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public AttributeValue addAttributeValue(Attribute attribute, AttributeOption option)
        throws TorqueException
    {
        AttributeValue av = AttributeValue.getNewInstance(attribute, searchIssue);
        av.setAttributeOption(option);
        searchIssue.addAttributeValue(av);
        return av;
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getAttributeValues()
        throws TorqueException
    {
    	return searchIssue.getAttributeValues();
    }
            
// in java/org/tigris/scarab/util/word/IssueSearch.java
public List getSetAttributeValues() throws TorqueException {
		return removeUnsetValues(searchIssue.getAttributeValues());
	}
            
// in java/org/tigris/scarab/util/Email.java
public static ScarabUser getArchiveUser()
        throws TorqueException
    {
        if(archiveUser==null)
        {
            archiveUser = ScarabUserManager.getInstance();
            archiveUser.setUserId(ARCHIVE_USER_ID);         
        }
        return archiveUser;
    }
85 
            
// in java/org/tigris/scarab/pipeline/DetermineTargetValve.java
catch (TorqueException e)
                    {
                        target = null;
                    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/tools/ScarabUserTool.java
catch (TorqueException e)
        {
            return null;
        }
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
            
// in java/org/tigris/scarab/attribute/OptionAttribute.java
catch (TorqueException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException te)
        {
            // Nothing to do
        }
            
// in java/org/tigris/scarab/om/NotificationStatusPeer.java
catch (TorqueException e) 
        {
			log.error("getPendingNotifications(): " + e);
		}
            
// in java/org/tigris/scarab/om/NotificationStatusPeer.java
catch (TorqueException e) 
        {
            log.error("getPendingNotifications(): " + e);
        }
            
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
catch (TorqueException e)
        {
            Log.get().error("setInternalAttribute(): " + e);
        }
            
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
catch (TorqueException e)
        {
            getLog().error("getName(): " + e);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
        {
            getLog().error("isIssueReasonRequired(): " + te);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
                getLog().error("isIssueReasonVisible(): " + te);
            }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
        {
            getLog().error("isIssueReasonRequiredInherited(): " + te);
        }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch (TorqueException te)
        {
            getLog().error("setActivity(): Cannot find activity's issue!: " + te);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
            {
                e.printStackTrace();
            }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException te)
        {
            // Nothing to do
        }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch (TorqueException e)
            {
                Log.get().error("", e);
            }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
            
// in java/org/tigris/scarab/om/IssueManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid Issue id ", e);
            }
            
// in java/org/tigris/scarab/om/AttributeGroupManager.java
catch(TorqueException e)
            {
                Log.get().warn("Invalid AttributeGroup id ", e);
            }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }
            
// in java/org/tigris/scarab/om/TransitionManager.java
catch (TorqueException te)
            {
                te.printStackTrace();
            }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e)
        {
            e.printStackTrace();
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException te)
        {
            // Nothing to do
        }
            
// in java/org/tigris/scarab/om/TransitionPeer.java
catch (TorqueException e) {
			log.error("getTransitions(): AttributeOption: " + fromOption.getOptionId() + ": " + e);
		}
            
// in java/org/tigris/scarab/om/NotificationRulePeer.java
catch (TorqueException e) {
                log.error("getPendingNotifications(): " + e);
            }
            
// in java/org/tigris/scarab/om/ActivitySet.java
catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
catch (TorqueException e)
                    {
                        Log.get().error("Unable to sort on module names", e);
                    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
            {
                getLog().error("Error getting the issue type name: ", e);
            }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
            {
                getLog().error("Error getting the issue type description: ", e);
            }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e)
        {
            this.getLog().error("getConditionsArray: " + e);
        }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException te)
        {
            // Nothing to do
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/UserPreferenceManager.java
catch (TorqueException te)
        {
            // Empty result...Failed to select one and only one row.
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
            {
                log.error("sendPendingNotifications(): No access to Issue [" + te + "]");
                // Can not proceed with this issue !
                continue;
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
                {
                    log.error("sendPendingNotifications(): No access to current Scarab User" + te);
                    // We can continue processing here. We just don't know how to process Emails
                    // for the current user.
                }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
        {
            Log.get().warn("Can not access Database while processing wakeupOnHoldTimeouts");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
        {
            Log.get().warn("Can not access Database while processing wakeupOnHoldTimeouts");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
        {
            Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
            Log.get().warn("db layer reported: ["+e.getMessage()+"]");
        }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
            {
                Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                Log.get().warn("db layer reported: ["+e.getMessage()+"]");
            }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e)
                {
                    Log.get().warn("Database acess error while retrieving status attribute value.(ignored)");
                    Log.get().warn("db layer reported: ["+e.getMessage()+"]");
                }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException e) 
                {
                    uniqueComments.add(notificationStatus);
                }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch(TorqueException te)
                    {
                        exception = te;
                    }
            
// in java/org/tigris/scarab/notification/ScarabNotificationManager.java
catch (TorqueException te)
            {
                log.error("sendPendingNotifications(): " + te);
                continue;
            }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TorqueException e) {
                    if (log.isEnabledFor(org.apache.log4j.Priority.WARN)) {
                        log
                                .warn(
                                        "mapAttributeOptionToAllModuleIssueTypes(String, String) - IssueTypeMApping alreadyt exists for this combination : attribute=" + attribute + ", option=" + option + ", it=" + it, null); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
                    }
                }
            
// in java/org/tigris/scarab/xmlrpc/ScarabUpdateHelper.java
catch (TorqueException e) {
                    log.error("Torque exception when sorting IssueTypeOptions.",e);
                }
            
// in java/org/tigris/scarab/screens/RSSDataExport.java
catch(TorqueException te){
            String msg = COULD_NOT_GENERATE_FEED_ERROR_DATABASE;
            Log.get().error(msg,te);
            data.getResponse().sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,msg);
        }
            
// in java/org/tigris/scarab/actions/HandleRoleRequests.java
catch (TorqueException e)
        {
            log().error("deleteRoleRequests: " + e); 
        }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (TorqueException te)
            {
                this.log().error("doSavetransitiondata(): " + te);
            }
            
// in java/org/tigris/scarab/actions/admin/GlobalAttributeEdit.java
catch (TorqueException te)
        {
            this.log().error("doDeleteTransition(): " + te);
        }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (TorqueException te) 
                        {
                            String msg = te.getMessage();
                            scarabR.setAlertMessage(msg);
                        }
            
// in java/org/tigris/scarab/actions/admin/AttributeGroupEdit.java
catch (TorqueException e)
                {
                    alreadySubmited = true;
                    scarabR.setAlertMessage(L10NKeySet.ResubmitError);
                }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
        {
            Log.get(this.getClass().getName())
                    .error("canMakeTransition: " + te);
        }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
            
// in java/org/tigris/scarab/services/TorqueService.java
catch (TorqueException te)
        {
            Log.get("org.apache.fulcrum").error("TorqueService.shutdown(): " + te);
        }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
catch (TorqueException e) {
            log.error(e);

            return null;
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException ex) 
                {
                    ex.printStackTrace();
                    importErrors.add(ex);
                }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
                    {
                        activitySetAttachmentOM = createAttachment(issueOM, activitySetAttachment);
                    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/util/EmailLink.java
catch (TorqueException te) {
                }
25 
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/tools/ScarabRequestTool.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw e;
        }
            
// in java/org/tigris/scarab/search/CachedQuery.java
catch (TorqueException e)
        {
            Log.get(LOGGER).warn("Search sql:\n" + sql + 
                "\nresulted in an exception: " + e.getMessage());
            throw e;
        }
            
// in java/org/tigris/scarab/om/MITList.java
catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException e)
        {
            // a way to satisfy method signature regarding "throws" for Torque class and Group class.
            // that is hide it all by throwing a RuntimeException.
            // usuages of this method must be careful of this!
            throw new ScarabRuntimeException((Localizable)null,e); //EXCEPTION
        }
            
// in java/org/tigris/scarab/om/ScarabModule.java
catch (TorqueException te)
            {
             throw new ScarabLocalizedTorqueException(
                     new ScarabException(
                             L10NKeySet.ExceptionTorqueGeneric, te));
            }
            
// in java/org/tigris/scarab/om/NotificationStatus.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/Transition.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric, te);
        }
            
// in java/org/tigris/scarab/om/NotificationRuleManager.java
catch(TorqueException te)
        {
            throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,te);
        }
            
// in java/org/tigris/scarab/om/Attribute.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/ActivitySet.java
catch (TorqueException e)
            {
                throw new ScarabException(L10NKeySet.ExceptionTorqueGeneric,e);
            }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch (TorqueException e)
                {
                    Log.get().error("Exception saving rio", e);
                    throw e; //EXCEPTION
                }
            
// in java/org/tigris/scarab/om/ModuleManager.java
catch(TorqueException e)
        {
            getMethodResult().clear();
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/notification/Notification.java
catch (TorqueException e) 
        {
            throw new RuntimeException(e);
        }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException te)
            {
                L10NMessage msg = new L10NMessage(L10NKeySet.ExceptionTorqueGeneric,te);
                throw new ScarabException(msg);
            }
            
// in java/org/tigris/scarab/workflow/CheapWorkflow.java
catch (TorqueException e) 
        {
            LocalizationKey key = L10NKeySet.ExceptionTorqueGeneric;
            L10NMessage msg = new L10NMessage(key,e);
            throw new ScarabException(msg,e);
        }
            
// in java/org/tigris/scarab/util/xmlissues/ScarabIssues.java
catch (TorqueException e)
        {
            e.printStackTrace();
            throw  new ScarabException(new L10NKey("Exception adding issue"+issue.getId()),e); // FIXME localise
        }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TorqueException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
10
unknown (Lib) TorqueRuntimeException 2 
            
// in java/org/tigris/scarab/om/MITList.java
public void remove()
        {
            List rawList = null;
            try
            {
                rawList = getMITListItems();
            }
            catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }

            if (rawList.contains(currentObject))
            {
                rawList.remove(currentObject);
                i.remove();
                expandedList = null;
            }
            else
            {
                throw new UnsupportedOperationException(
                    "Removing items "
                        + "from a list containing wildcards is not supported."); //EXCEPTION
            }
        }
            
// in java/org/tigris/scarab/om/MITList.java
public List getExpandedMITListItems()
    {
        if (expandedList == null)
        {
            List items = new ArrayList();
            try
            {
                for (Iterator rawItems = getMITListItems().iterator();
                    rawItems.hasNext();
                    )
                {
                    MITListItem item = (MITListItem) rawItems.next();
                    calculateIsAllMITs(item);
                    if (!item.isSingleModule())
                    {
                        Module[] modules =
                            getScarabUser().getModules(
                                ScarabSecurity.ISSUE__SEARCH);
                        for (int i = 0; i < modules.length; i++)
                        {
                            Module module = modules[i];
                            if (item.isSingleIssueType())
                            {
                                IssueType type = item.getIssueType();
                                if (module.getRModuleIssueType(type) != null)
                                {
                                    MITListItem newItem =
                                        MITListItemManager.getInstance();
                                    newItem.setModule(module);
                                    newItem.setIssueType(type);
                                    newItem.setListId(getListId());
                                    items.add(newItem);
                                }
                            }
                            else
                            {
                                addIssueTypes(module, items);
                            }
                        }
                    }
                    else if (!item.isSingleIssueType())
                    {
                        addIssueTypes(getModule(item), items);
                    }
                    else
                    {
                        items.add(item);
                    }
                }
            }
            catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            expandedList = items;
        }

        return expandedList;
    }
2 
            
// in java/org/tigris/scarab/om/MITList.java
catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/om/MITList.java
catch (Exception e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }
0 0 0 0
unknown (Lib) TransformerException 0 0 3 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader getScarabFormattedReader(
            final Object input,
            final ImportType type,
            final Module currModule) throws IOException, TransformerException, TorqueException, JDOMException 
    {
        Reader returnValue = null;
        
        if( SCARAB == type )
        {
            // is in correct format already, just return the input stream
            returnValue = readerFor(input);
        }
        else if( BUGZILLA == type )
        {
            // Location of the extensions directory for Bugzilla
            // Transform configuration, mappings and attachments are here
            // TODO move onto resourceDirectory derivative
            final String extensions = System.getProperty("catalina.home") + "/../extensions/bugzilla";
            
            // Locate the Bugzilla to Scarab XSL transform
            final InputStream xsl = getClass().getResourceAsStream(BUGZILLA_XSL);
            
            // Transform Bugzilla xml to scarab format
            // (Trailing '/' to resources is deliberate)
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, extensions);
            
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        else if( JIRA == type )
        {
                    
            // transform xml to scarab format
            final InputStream xsl = getClass().getResourceAsStream(JIRA_XSL);
            final Reader result = transformXML(
                    new StreamSource(readerFor(input)), xsl, currModule, resourceDirectory);
            // insert missing information (module)
            returnValue = insertModuleNode(result, currModule);
        }
        return returnValue;
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader transformXML(final Source xmlSource, 
            final InputStream xsl,
            final Module currModule,
            final String resources)
        throws TransformerException
    {
            final StringWriter writer = new StringWriter();
            final StreamResult result = new StreamResult(writer);            

            // The resolver will help find the transform's resources
            if (resources != null) {
                transformerFactory.setURIResolver(new TransformResolver(resources));
            }
            
            final Transformer transformer = (xsl != null)
                    ? transformerFactory.newTransformer(new StreamSource(xsl))
                    : transformerFactory.newTransformer();
            
            transformer.setOutputProperty(OutputKeys.INDENT, "yes" );
            
            // Pass this parameter to the transform to locate resources,
            // particularly attachments. For attachments, the
            // Scarab instance must be able to see this absolute path
            transformer.setParameter("resources_path", resources);

            // Tell the transformer the module_code
            transformer.setParameter("module_code", currModule.getCode());
            
            if( xsl == null )
            {
                // plain outputting (used on a DomSource)
                transformer.setOutputProperty(OutputKeys.METHOD, "xml");          
                transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");                
            }
            transformer.transform(xmlSource, result);   
            //System.out.println(writer.toString());
            return new StringReader(writer.toString());
    }
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
private Reader insertModuleNode(final Reader result, 
            final Module currModule) 
        throws TorqueException, JDOMException, IOException, TransformerException 
    {
        
        final ScarabUser user = ScarabUserManager.getInstance(currModule.getOwnerId());        
        
        // Core Java: org.w3c.dom version (jdk1.4+ compatible)
//        final DocumentBuilder docBuilder = documentBuilderFactory.newDocumentBuilder();
//        final Document doc = docBuilder.parse( new InputSource(result) );
//        // insert module
//        final Element root = doc.getDocumentElement();
//        final Element moduleNode = doc.createElement("module");
//        final Element idNode = doc.createElement("id");
//        final Element parentIdNode = doc.createElement("parent-id");
//        final Element nameNode = doc.createElement("name");
//        final Element ownerNode = doc.createElement("owner");
//        final Element descriptionNode = doc.createElement("description");
//        final Element urlNode = doc.createElement("url");
//        final Element domainNode = doc.createElement("domain");
//        final Element codeNode = doc.createElement("code");
//        
//        idNode.appendChild(doc.createTextNode(String.valueOf(currModule.getModuleId())));
//        parentIdNode.appendChild(doc.createTextNode(String.valueOf(currModule.getParentId())));
//        nameNode.appendChild(doc.createTextNode(currModule.getName()));
//        ownerNode.appendChild(doc.createTextNode(user.getUserName()));
//        descriptionNode.appendChild(doc.createTextNode(currModule.getDescription()));
//        urlNode.appendChild(doc.createTextNode(currModule.getUrl()));
//        domainNode.appendChild(doc.createTextNode(currModule.getHttpDomain()));
//        codeNode.appendChild(doc.createTextNode(currModule.getCode()));
//        
//        moduleNode.appendChild(idNode);
//        moduleNode.appendChild(parentIdNode);
//        moduleNode.appendChild(nameNode);
//        moduleNode.appendChild(ownerNode);
//        moduleNode.appendChild(descriptionNode);
//        moduleNode.appendChild(urlNode);
//        moduleNode.appendChild(domainNode);
//        moduleNode.appendChild(codeNode);
//        
//        root.appendChild(moduleNode);
        
        // JDom version (jdk1.3 compatible)
        
        final SAXBuilder builder = new SAXBuilder();
        builder.setEntityResolver(new EntityResolver()
        {
                public InputSource resolveEntity(String publicId,
                                                 String systemId)
                    throws SAXException
                {
                    return ImportIssues.this.resolveEntity(this, publicId, systemId);
                }   
        });
        final Document doc = builder.build(result);        
        final Element root = doc.getRootElement();

        final Element moduleNode = new Element("module");
        final Element idNode = new Element("id");
        final Element parentIdNode = new Element("parent-id");
        final Element nameNode = new Element("name");
        final Element ownerNode = new Element("owner");
        final Element descriptionNode = new Element("description");
        final Element urlNode = new Element("url");
        final Element domainNode = new Element("domain");
        final Element codeNode = new Element("code");    
        
        idNode.setText(String.valueOf(currModule.getModuleId()));
        parentIdNode.setText(String.valueOf(currModule.getParentId()));
        nameNode.setText(currModule.getRealName());
        ownerNode.setText(user.getUserName());
        descriptionNode.setText(currModule.getDescription());
        urlNode.setText(currModule.getUrl());
        domainNode.setText(currModule.getHttpDomain());
        codeNode.setText(currModule.getCode());
        
        moduleNode.addContent(idNode)
                .addContent(parentIdNode)
                .addContent(nameNode)
                .addContent(ownerNode)
                .addContent(descriptionNode)
                /*
                 * These are excluded for now, since your database domain may 
                 * not correspond to currModule.getHttpDomain().
                .addContent(urlNode)
                .addContent(domainNode)
                 */
                .addContent(codeNode);
        root.addContent(2,moduleNode);
        
        return transformXML(new JDOMSource(doc), null, currModule, null);
    }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
1 
            
// in java/org/tigris/scarab/util/xmlissues/ImportIssues.java
catch (TransformerException e)
        {
            LOG.error(msg, e);
            throw new ScarabException(L10NKeySet.ExceptionGeneral,e); //EXCEPTION
        }
0
unknown (Lib) TurbineException 3 
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        
        try
        {
            // Check, whether password is expired 
            if(user.isPasswordExpired())
            {
                // Under no conditions an expired password will be
                // accepted. The request is always forwarded to the
                // password change mask until the password has been reset. [HD]
                data.setTarget("ChangePassword.vm");
                data.save();
                context.invokeNext(data);
                return;
            }
            adjustCurrentModule(user, data);
            adjustCurrentIssueType(user, data);
        }
        catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }

        // set the thread key 
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.THREAD_QUERY_KEY);
        if (key != null) 
        {
            user.setThreadKey(new Integer(key));
        }
        else
        {
            user.setThreadKey(null);
        }
        
        // remove any report that was aborted
        String reportKey = parameters.getString(ScarabConstants.REMOVE_CURRENT_REPORT);
        if (reportKey != null && reportKey.length() > 0)
        {
            user.setCurrentReport(reportKey, null);
        }

        // remove the current module/issuetype list, if needed
        String removeMitKey = 
            parameters.getString(ScarabConstants.REMOVE_CURRENT_MITLIST_QKEY);
        String target = data.getTarget();
        boolean xmitScreen =XMIT_SCREENS.containsKey(target); 
        if (removeMitKey != null 
            || !xmitScreen)
        {
            Log.get().debug("xmit list set to null");
            user.setCurrentMITList(null);
        }

        // override the current module/issuetype list if one is given
        // in the url.
        String mitid = parameters.getString(ScarabConstants.CURRENT_MITLIST_ID);
        if (mitid != null) 
        {
            MITList mitList = null;
            try
            {
                // FIXME: no getInstance(Integer)
                mitList = MITListManager.getInstance(new NumberKey(mitid));
                user.setCurrentMITList(mitList);
                mitList.setScarabUser(user);
            }
            catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentModule(ScarabUser user, RunData data)
        throws TurbineException, Exception
    {
        Module module = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_MODULE);
        if (key != null) 
        {
            try
            {
                module = ModuleManager.getInstance(new Integer(key));
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else if (parameters.getString("id") != null) 
        {
            try  
            {
                module = IssueManager.getIssueById(parameters.getString("id")).getModule();
                parameters.setString(ScarabConstants.CURRENT_MODULE, 
                             module.getQueryKey());
            }
            catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
        }
        if(module!=null)
        {
            user.setCurrentModule(module);
        }
    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentIssueType(ScarabUser user, RunData data)
        throws TurbineException
    {
        IssueType issueType = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_ISSUE_TYPE);
        if (key != null && key.length() > 0)
        {
            try
            {
                issueType = IssueTypeManager.getInstance(new Integer(key));
                if (Log.get().isDebugEnabled()) 
                {
                    Log.get().debug("setting issue type: " + 
                         issueType.getName() + " based on curit");        
                }
            }
            catch (NumberFormatException noIssueType)
            {
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else 
        {
            String templateId = data.getParameters().getString("templateId");
            if (templateId != null && templateId.length() > 0) 
            {
                try
                {
                    IssueType templateType = IssueManager.getInstance(
                        new Long(templateId)).getIssueType();
                    issueType = templateType.getIssueTypeForTemplateType();
                    parameters.setString(ScarabConstants.CURRENT_ISSUE_TYPE,
                                         issueType.getQueryKey());
                    if (Log.get().isDebugEnabled()) 
                    {
                        Log.get().debug("setting issue type: " + 
                            issueType.getName() + " based on template");
                    }
                }
                catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
            }
        }
        
        if(issueType != null)
        {
            user.setCurrentIssueType(issueType);
        }

    }
3 
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
12 
            
// in java/org/tigris/scarab/pipeline/ResetCacheValve.java
public final void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // clear the short-term cache
        ScarabCache.clear();

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/AnonymousLoginValve.java
public void invoke(RunData data, ValveContext context) throws IOException, TurbineException
    {
        String target = data.getTarget();
        
        // Only try this if accessing an authenticated page:
        if (!nonAnonymousTargets.contains(target) && target.indexOf("help,") == -1)
        {
            ScarabUser user = (ScarabUser)data.getUserFromSession();
            // If there's no user, we will try login:

            if (null == user || user.getUserId() == null || !user.hasLoggedIn())
            {
                boolean isLoggedIn = false;
                String username   = data.getParameters().get("userid");
                // Maybe a User has been provided in the parameter list ?    
                if(username != null)
                {
                    String password = data.getParameters().get("password");
                    final ScarabRequestTool scarabR = null;
                    try
                    {
                        // Try logging in. Note No ScarabRequestTool available here,
                        // so no screen action can be prepared here.
                        isLoggedIn = Login.authentifyWithCredentials(data, scarabR, username, password);
                    }
                    catch(Exception e)
                    {
                        // login failed (user unknown, not confirmed, wrong password, ...) no action taken here
                        // Maybe even anonymous login should be forbidden now ?
                        // See below
                    }
                }

                // We were not able to log in an authenticated user (as possibly tried above) but anonymous login is enabled
                if(!isLoggedIn && anonymousAccessAllowed)
                {
                    // So perform anonymous login here
                    Login.anonymousLogin(data);
                }
                
            }
        }
        context.invokeNext(data);        
    }
            
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve22.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // if we are forcing a particular charset, use it.  Hopefully
        // client has encoded for this default. This is the same 
        // property that will force the charset in our responses.
        String encoding = REQUIRED_CHARSET;   

        if (encoding == null) 
        {
            // guess the charset from the client's headers
            encoding = ComponentLocator.getMimeTypeService().getCharSet(data.getLocale());
        }

        // if the charset was specified in the configuration or the charset
        // map contained a value for the locale, set it, otherwise leave
        // it as the servlet engine has set it.
        if (encoding != null) 
        {
            // data.getRequest().setCharacterEncoding(encoding);
            data.setCharSet(encoding);
        }
        
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/DetermineTargetValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ParameterParser parameters = data.getParameters();
        if (! data.hasTarget())
        {
            String target = parameters.getString("template");
            String query  = parameters.getString("query");
            if(query==null)
            {
                query = parameters.getString("queryId");
            }

            if (query != null && getEventKey(parameters)==null)
            {
                parameters.setString("eventSubmit_doSelectquery", "foo");
                // Allows short link to public/personal queries
                // $scarabRoot/issues/query/<queryId>/curmodule/<moduleId>                
                if (target == null) target="IssueList.vm";
                data.setTarget(target);
                if (parameters.getString("tqk")      == null) parameters.setString("tqk", ""+0);
                if (parameters.getString("action")   == null) data.setAction("Search");
                if (parameters.getString("go")       == null) parameters.setString("go",query);
            }
            else if (target != null)
            {
                data.setTarget(target);
                Log.get().debug("Set target from request parameter");
            }
            else if (parameters.getString("id") != null)
            {
                // Allows short link to issue
                // $scarabRoot/issues/id/<issueId>
                data.setTarget("ViewIssue.vm");
            }
            else
            {
                //data.getResponse().sendError(404);
                //return;
                ScarabUser user = (ScarabUser)data.getUserFromSession();
                if(user!= null && user.getUserId() != null && user.getUserId().longValue() > 0)
                {
                    ScarabRequestTool scarabR = ((ScarabRequestTool)Module.getTemplateContext(data)
                            .get(ScarabConstants.SCARAB_REQUEST_TOOL));
                    org.tigris.scarab.om.Module module = scarabR.getCurrentModule();
                    
                    try
                    {
                        if(module != null)
                        {
                            target = user.getHomePage(module);
                        }
                        else
                        {
                            target = user.getHomePage();
                        }
                    }
                    catch (TorqueException e)
                    {
                        target = null;
                    }
                }
                if(target == null)
                {
                    target = Turbine.getConfiguration().getString(
                            Turbine.TEMPLATE_HOMEPAGE);                    
                }
                data.setTarget(target);
                Log.get().debug("Set target to ["+target+"]");

            }
        }
        
        if (Log.get().isDebugEnabled())
        {
            Log.get().debug("Target is now: " + data.getTarget());
        }

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/DetermineCharsetValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        // if we are forcing a particular charset, use it.  Hopefully
        // client has encoded for this default. This is the same 
        // property that will force the charset in our responses.
        String encoding = REQUIRED_CHARSET;   

        if (encoding == null) 
        {
            // guess the charset from the client's headers
            encoding = ComponentLocator.getMimeTypeService().getCharSet(data.getLocale());
        }

        // if the charset was specified in the configuration or the charset
        // map contained a value for the locale, set it, otherwise leave
        // it as the servlet engine has set it.
        if (encoding != null) 
        {
            data.getRequest().setCharacterEncoding(encoding);
            data.setCharSet(encoding);
        }
        
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/TimingInfoValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        if (DEBUG) 
        {
            Long start = (Long)data.getRequest().getAttribute(KEY);
            if (start == null) 
            {
                try 
                {
                    data.getResponse().setBufferSize(10000000);
                }
                catch (Exception e)
                {
                    LOG.debug("Could not set high buffer size so client may " +
                              "affect timing results.");
                }
                ((ScarabRequestTool)Module.getTemplateContext(data)
                    .get("scarabR")).startTimer();
                data.getRequest()
                    .setAttribute(KEY, new Long(System.currentTimeMillis()));
            }
            else
            {
                String s = "Action=" + data.getAction() + " and template=" + 
                    data.getTarget() + " took: " + 
                    (System.currentTimeMillis() - start.longValue()) + " ms";
                LOG.debug(s);
                try 
                {
                    data.getResponse().getWriter().println(s);        
                }
                catch (Exception ignore)
                {
                    // maybe this was a binary response?
                    // we still logged it, so ignore
                }
            }
        }
            
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/SetLocaleValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ScarabUser user = (ScarabUser) data.getUser();

        // Ensure we only deal with exsiting users
        if (user != null && user.getUserId() != null)
        {
            try
            {
                String acceptLanguage = LocalizationService.ACCEPT_LANGUAGE;
                HttpServletRequest request = data.getRequest();
                String browserLocaleAsString =
                    request.getHeader(acceptLanguage);

                Locale userLocale = user.getLocale();
                Locale browserLocale =
                    Localization.getLocale(browserLocaleAsString);

                if (!userLocale.equals(browserLocale))
                {
                    storePreferredLocale(user, browserLocaleAsString);
                }
            }
            catch (Exception e)
            {
                LOG.warn(
                    "Could not set locale info for user ["
                        + user.getName()
                        + "]");
            }
        }
        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ScarabUser user = (ScarabUser)data.getUser();
        
        try
        {
            // Check, whether password is expired 
            if(user.isPasswordExpired())
            {
                // Under no conditions an expired password will be
                // accepted. The request is always forwarded to the
                // password change mask until the password has been reset. [HD]
                data.setTarget("ChangePassword.vm");
                data.save();
                context.invokeNext(data);
                return;
            }
            adjustCurrentModule(user, data);
            adjustCurrentIssueType(user, data);
        }
        catch(Exception e)
        {
            Log.get().error("", e);
            // Ignore on purpose because if things
            // are screwed up, we don't need to know about it.
        }

        // set the thread key 
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.THREAD_QUERY_KEY);
        if (key != null) 
        {
            user.setThreadKey(new Integer(key));
        }
        else
        {
            user.setThreadKey(null);
        }
        
        // remove any report that was aborted
        String reportKey = parameters.getString(ScarabConstants.REMOVE_CURRENT_REPORT);
        if (reportKey != null && reportKey.length() > 0)
        {
            user.setCurrentReport(reportKey, null);
        }

        // remove the current module/issuetype list, if needed
        String removeMitKey = 
            parameters.getString(ScarabConstants.REMOVE_CURRENT_MITLIST_QKEY);
        String target = data.getTarget();
        boolean xmitScreen =XMIT_SCREENS.containsKey(target); 
        if (removeMitKey != null 
            || !xmitScreen)
        {
            Log.get().debug("xmit list set to null");
            user.setCurrentMITList(null);
        }

        // override the current module/issuetype list if one is given
        // in the url.
        String mitid = parameters.getString(ScarabConstants.CURRENT_MITLIST_ID);
        if (mitid != null) 
        {
            MITList mitList = null;
            try
            {
                // FIXME: no getInstance(Integer)
                mitList = MITListManager.getInstance(new NumberKey(mitid));
                user.setCurrentMITList(mitList);
                mitList.setScarabUser(user);
            }
            catch (TorqueException e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentModule(ScarabUser user, RunData data)
        throws TurbineException, Exception
    {
        Module module = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_MODULE);
        if (key != null) 
        {
            try
            {
                module = ModuleManager.getInstance(new Integer(key));
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else if (parameters.getString("id") != null) 
        {
            try  
            {
                module = IssueManager.getIssueById(parameters.getString("id")).getModule();
                parameters.setString(ScarabConstants.CURRENT_MODULE, 
                             module.getQueryKey());
            }
            catch (Exception e)
            {
                // ignore
                Log.get().debug("'id' parameter was available, "
                    + parameters.getString("id") + 
                    ", but did not contain enough info to create issue.");
            }
        }
        if(module!=null)
        {
            user.setCurrentModule(module);
        }
    }
            
// in java/org/tigris/scarab/pipeline/FreshenUserValve.java
private void adjustCurrentIssueType(ScarabUser user, RunData data)
        throws TurbineException
    {
        IssueType issueType = null;
        ParameterParser parameters = data.getParameters();
        String key = parameters.getString(ScarabConstants.CURRENT_ISSUE_TYPE);
        if (key != null && key.length() > 0)
        {
            try
            {
                issueType = IssueTypeManager.getInstance(new Integer(key));
                if (Log.get().isDebugEnabled()) 
                {
                    Log.get().debug("setting issue type: " + 
                         issueType.getName() + " based on curit");        
                }
            }
            catch (NumberFormatException noIssueType)
            {
            }
            catch (Exception e)
            {
                throw new TurbineException(e); //EXCEPTION
            }
        }
        else 
        {
            String templateId = data.getParameters().getString("templateId");
            if (templateId != null && templateId.length() > 0) 
            {
                try
                {
                    IssueType templateType = IssueManager.getInstance(
                        new Long(templateId)).getIssueType();
                    issueType = templateType.getIssueTypeForTemplateType();
                    parameters.setString(ScarabConstants.CURRENT_ISSUE_TYPE,
                                         issueType.getQueryKey());
                    if (Log.get().isDebugEnabled()) 
                    {
                        Log.get().debug("setting issue type: " + 
                            issueType.getName() + " based on template");
                    }
                }
                catch (Exception e)
                {
                    Log.get().warn("'templateId' parameter was available, "
                        + parameters.getString("templateId") +
                        ", but invalid.", e);
                }
            }
        }
        
        if(issueType != null)
        {
            user.setCurrentIssueType(issueType);
        }

    }
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
public void invoke(RunData data, ValveContext context) throws IOException, TurbineException
    {
        try
        {
    	   if (bNTLMActive &&
                   (
                   ((null == data.getUserFromSession() || data.getUserFromSession().getUserName().trim().length()==0) && null == data.getUser())
                   || ((ScarabUser)data.getUserFromSession()).isUserAnonymous()
                   )
                   && ( !data.getAction().equals("Logout")
                           && !data.getAction().equals("Login")
                           && !data.getTarget().equals("Register.vm")
                           && !data.getTarget().equals("ForgotPassword.vm")
                    ))
            {
                authenticateNtlm(data);
            }
        }
        catch(TorqueException e)
        {
        	throw new RuntimeException(e);
        }
    	   context.invokeNext(data);       
    }
            
// in java/org/tigris/scarab/pipeline/SetInfoMessageValve.java
public void invoke(RunData data, ValveContext context)
        throws IOException, TurbineException
    {
        ((ScarabRequestTool)Module.getTemplateContext(data)
            .get(ScarabConstants.SCARAB_REQUEST_TOOL)).setInfoMessage(message);

        // Pass control to the next Valve in the Pipeline
        context.invokeNext(data);
    }
0 0 0
unknown (Lib) TurbineSecurityException 6 
            
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
public void delete(final ScarabUser user) throws TorqueException, TurbineSecurityException 
    { 
        boolean hasPermission = true;
        if (getModule() != null)
        {
            hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,getModule());
        }
        else //getModule() is null for X Project queries, so get the modules from the MIT List
        {
            final List moduleList = user.getCurrentMITList().getModules();
            for (Iterator iter = moduleList.iterator(); iter.hasNext(); )
            {
                hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,(Module)iter.next());
                if (!hasPermission)
                {
                    break;
                }
            }
        }
        if (hasPermission)
        {
            final Criteria c = new Criteria()
                .add(RModuleUserAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleUserAttributePeer.LIST_ID, getListId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleUserAttributePeer.doDelete(c);
        }
        else
        {
            throw new TurbineSecurityException(ScarabConstants.NO_PERMISSION_MESSAGE); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void remove()
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void rename(String name)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void grant(User user, RoleSet roleSet)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void revoke(User user, Role role)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void revoke(User user, RoleSet roleSet)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
0 13 
            
// in java/org/tigris/scarab/om/MITList.java
public List getAllRModuleUserAttributes() 
    throws TorqueException, DataSetException, TurbineSecurityException
    {
        List rmuas = getSavedRMUAs();
        return rmuas;
    }
            
// in java/org/tigris/scarab/om/MITList.java
public List getCommonRModuleUserAttributes() 
        throws TorqueException, DataSetException, TurbineSecurityException
    {
        final List matchingRMUAs = new ArrayList();
        List rmuas = getSavedRMUAs();
        Iterator i = rmuas.iterator();
        final ScarabUser user = getScarabUser();
        while (i.hasNext())
        {
            final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
            final Attribute att = rmua.getAttribute();
            if (isCommon(att, false))
            {
                matchingRMUAs.add(rmua);
            }
        }

        // None of the saved RMUAs are common for these pairs
        // Delete them and seek new ones.
        if (matchingRMUAs.isEmpty())
        {
            i = rmuas.iterator();
            while (i.hasNext())
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                rmua.delete(user);
            }
            final int sizeGoal = 3;
            int moreAttributes = sizeGoal;

            // First try saved RMUAs for first module-issuetype pair
            final MITListItem item = getFirstItem();
            final Module module = getModule(item);
            final IssueType issueType = item.getIssueType();
            rmuas = user.getRModuleUserAttributes(module, issueType);
            // Next try default RMUAs for first module-issuetype pair
            if (rmuas.isEmpty())
            {
                rmuas = module.getDefaultRModuleUserAttributes(issueType);
            }

            // Loop through these and if find common ones, save the RMUAs
            i = rmuas.iterator();
            while (i.hasNext() && moreAttributes > 0)
            {
                final RModuleUserAttribute rmua = (RModuleUserAttribute) i.next();
                final Attribute att = rmua.getAttribute();
                if (isCommon(att, false) && !matchingRMUAs.contains(rmua))
                {
                    final RModuleUserAttribute newRmua =
                        getNewRModuleUserAttribute(att);
                    newRmua.setOrder(1);
                    newRmua.save();
                    matchingRMUAs.add(rmua);
                    moreAttributes--;
                }
            }

            // if nothing better, go with random common attributes
            moreAttributes = sizeGoal - matchingRMUAs.size();
            if (moreAttributes > 0)
            {
                Iterator attributes = getCommonAttributes(false).iterator();
                int k = 1;
                while (attributes.hasNext() && moreAttributes > 0)
                {
                    Attribute att = (Attribute) attributes.next();
                    boolean isInList = false;
                    i = matchingRMUAs.iterator();
                    while (i.hasNext())
                    {
                        RModuleUserAttribute rmua =
                            (RModuleUserAttribute) i.next();
                        if (rmua.getAttribute().equals(att))
                        {
                            isInList = true;
                            break;
                        }
                    }
                    if (!isInList)
                    {
                        RModuleUserAttribute rmua =
                            getNewRModuleUserAttribute(att);
                        rmua.setOrder(k++);
                        rmua.save();
                        matchingRMUAs.add(rmua);
                        moreAttributes--;
                    }
                }
            }
        }

        return matchingRMUAs;
    }
            
// in java/org/tigris/scarab/om/RModuleUserAttribute.java
public void delete(final ScarabUser user) throws TorqueException, TurbineSecurityException 
    { 
        boolean hasPermission = true;
        if (getModule() != null)
        {
            hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,getModule());
        }
        else //getModule() is null for X Project queries, so get the modules from the MIT List
        {
            final List moduleList = user.getCurrentMITList().getModules();
            for (Iterator iter = moduleList.iterator(); iter.hasNext(); )
            {
                hasPermission = user.hasPermission(ScarabSecurity.USER__EDIT_PREFERENCES,(Module)iter.next());
                if (!hasPermission)
                {
                    break;
                }
            }
        }
        if (hasPermission)
        {
            final Criteria c = new Criteria()
                .add(RModuleUserAttributePeer.MODULE_ID, getModuleId())
                .add(RModuleUserAttributePeer.USER_ID, getUserId())
                .add(RModuleUserAttributePeer.ISSUE_TYPE_ID, getIssueTypeId())
                .add(RModuleUserAttributePeer.LIST_ID, getListId())
                .add(RModuleUserAttributePeer.ATTRIBUTE_ID, getAttributeId());
            RModuleUserAttributePeer.doDelete(c);
        }
        else
        {
            throw new TurbineSecurityException(ScarabConstants.NO_PERMISSION_MESSAGE); //EXCEPTION
        }
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void remove()
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void rename(String name)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void grant(User user, Role role)
        throws TurbineSecurityException
    {
        TurbineSecurity.grant(user,this,role);

        // TODO: Needs to be refactored into the Users system?
        ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.GET_ACL);
        ScarabUserManager.getMethodResult().remove(user, ScarabUserManager.HAS_ROLE_IN_MODULE, (Serializable)role, this);
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void grant(User user, RoleSet roleSet)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void revoke(User user, Role role)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabModule.java
public void revoke(User user, RoleSet roleSet)
        throws TurbineSecurityException
    {
        throw new TurbineSecurityException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
protected void deleteRModuleUserAttribute(final RModuleUserAttribute rmua)
                throws TorqueException, TurbineSecurityException
            {
                privateDeleteRModuleUserAttribute(rmua);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
private void privateDeleteRModuleUserAttribute(final RModuleUserAttribute rmua)
        throws TorqueException, TurbineSecurityException
    {
        rmua.delete(this);
    }
            
// in java/org/tigris/scarab/feeds/QueryFeed.java
public SyndFeed getFeed() throws Exception, TorqueException, DataSetException, TurbineSecurityException
    {
        SyndFeed feed = new SyndFeedImpl();
        feed.setTitle(query.getName());
        String link = scarabLink.setAction("Search").addPathInfo("go",query.getQueryId()).toString();
        feed.setLink(link);
        feed.setDescription(query.getDescription());
        List entries = new ArrayList();
        for(Iterator i = results.iterator(); i.hasNext();)
        {
            SyndEntry entry = new SyndEntryImpl();
            SyndContent description = new SyndContentImpl();
            QueryResult queryResult = (QueryResult)i.next();
            String title = queryResult.getUniqueId();
            entry.setTitle(title);
            
            Issue issue = IssueManager.getInstance(Long.valueOf(queryResult.getIssueId()));

            link = scarabLink.getIssueIdAbsoluteLink(issue).toString();
            entry.setLink(link);

            Date publishedDate = null;
            if(issue.getModifiedDate()!= null){
                publishedDate = issue.getModifiedDate();
            }
            else {
                publishedDate = issue.getCreatedDate();
            }
            entry.setPublishedDate(publishedDate);

            description = new SyndContentImpl();
            description.setType("text/html");
            String desc = "";
            Iterator avIteratorCSV = queryResult.getAttributeValuesAsCSV().iterator();
            Iterator avIterator = query.getMITList().getAllRModuleUserAttributes().iterator();
            while (avIterator.hasNext())
            {
                String value = (String)avIteratorCSV.next();
                RModuleUserAttribute av = (RModuleUserAttribute)avIterator.next();
                desc = desc + "<b>" + av.getAttribute().getName()+":</b>" + value +"<br/>";
            }
            description.setValue(ScarabUtil.filterNonXml(desc));

            entry.setDescription(description);
            entries.add(entry);
        }
        feed.setEntries(entries);
        feed.setFeedType(format);
        return feed;
    }
            
// in java/org/tigris/scarab/actions/ScarabAccessController.java
public void doPerform( RunData data )
        throws TurbineSecurityException
    {
        User user = data.getUser();

        if (user.hasLoggedIn() && user.isConfirmed())
        {
            AccessControlList acl = (AccessControlList)
                    data.getSession().getAttribute(
                            AccessControlList.SESSION_KEY);

            if (acl == null)
            {
                acl = TurbineSecurity.getACL(user);
                data.getSession().setAttribute(
                        AccessControlList.SESSION_KEY, acl);
            }
            data.setACL(acl);
        }
    }
3 
            
// in java/org/tigris/scarab/actions/ForgotPassword.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.InvalidUsername,username);
            getScarabRequestTool(context).setAlertMessage(msg);
            Log.get().error("ForgotPassword: ", e);
            setTarget(data, "ForgotPassword.vm");
            return false;
        }
            
// in java/org/tigris/scarab/actions/ConfigureIssueList.java
catch (TurbineSecurityException tse)
	            {
	                scarabR.setAlertMessage(NO_PERMISSION_MESSAGE);
	            }
            
// in java/org/tigris/scarab/actions/Login.java
catch (TurbineSecurityException e)
        {
            Localizable msg = new L10NMessage(L10NKeySet.ExceptionTurbineGeneric,e);
            setAlertMessage(scarabR,msg);
            failAction(data, "Login.vm");
            return false;
        }
0 0
unknown (Lib) UnknownEntityException 2 
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public void saveGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            if (!((Persistent)group).isNew()) 
            {
                group.save();
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void removeGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            lockExclusive();
            if (!((Persistent)group).isNew()) 
            {
                ((Module)group).setDeleted(true);
                group.save();
                getAllGroups().remove(group);
            }
        }
        catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
0 4 
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public void saveGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            if (!((Persistent)group).isNew()) 
            {
                group.save();
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("saveGroup(Group) failed" ,e); //EXCEPTION
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void removeGroup(Group group)
        throws DataBackendException, UnknownEntityException
    {
        try
        {
            lockExclusive();
            if (!((Persistent)group).isNew()) 
            {
                ((Module)group).setDeleted(true);
                group.save();
                getAllGroups().remove(group);
            }
        }
        catch(Exception e)
        {
            Log.get().error("Failed to delete a Group");
            Log.get().error(e);
            throw new DataBackendException("removeGroup(Group) failed", e); //EXCEPTION
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/security/ScarabDBSecurityService.java
public synchronized void renameGroup(Group group, String name)
        throws DataBackendException, UnknownEntityException
    {
        throw new DataBackendException("rename is not supported"); //EXCEPTION

        /* this stuff is cut-n-paste
        boolean groupExists = false;
        try
        {
            lockExclusive();
            groupExists = checkExists(group);
            if(groupExists)
            {
                ((SecurityObject)group).setName(name);
                Criteria criteria = GroupPeer.buildCriteria(group);
                GroupPeer.doUpdate(criteria);
                return;
            }
        }
        catch(Exception e)
        {
            throw new DataBackendException("renameGroup(Group,String)" ,e);
        }
        finally
        {
            unlockExclusive();
        }
        throw new UnknownEntityException("Unknown group '" + group + "'");
        */
    }
            
// in java/org/tigris/scarab/services/security/ScarabLDAPDBSecurityService.java
public User getAuthenticatedUser(String username, String password)
        throws DataBackendException, UnknownEntityException, 
            PasswordMismatchException {
        LDAPUserInfoCallback info = authenticate(username, password);

        /* First try to auth from ldap */
        if (info != null) {
            /* Check if user exists */
            if (!super.userManager.accountExists(username)) {
                try {
                    super.userManager.createAccount(createUser(username,
                            password, info), password);
                } catch (EntityExistsException e) {
                }

                
            } else {
                User curruser = userManager.retrieve(username);
                copyProps(curruser, info);

                String encrypted = TurbineSecurity.encryptPassword(password);

                if (!encrypted.equals(curruser.getPassword())) {
                    curruser.setPassword(encrypted);
                }

                userManager.store(curruser);
            }

            return userManager.retrieve(username);
        }

        return userManager.retrieve(username, password);
    }
4 
            
// in java/org/tigris/scarab/pipeline/NTLMLoginValve.java
catch (UnknownEntityException e)
            {
                log.error("authenticateNtlm: " + e);
            }
            
// in java/org/tigris/scarab/om/ScarabUserImpl.java
catch (UnknownEntityException ex) {
                        Log.get().error("tried to copy unknown role from anonymous user: " + ex);
                    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
            
// in java/org/tigris/scarab/actions/Login.java
catch (UnknownEntityException e)
        {
            setAlertMessage(scarabR, L10NKeySet.InvalidUsernameOrPassword);
            Log.get().info("Invalid login attempted: " + e.getMessage());
            failAction(data, "Login.vm");            
            return null;
        }
1 
            
// in java/org/tigris/scarab/om/AttributeGroup.java
catch(org.apache.fulcrum.security.util.UnknownEntityException uee)
                {
                    throw new TorqueException("failed to get user's groups", uee);
                }
0
unknown (Lib) UnsupportedCallbackException 1 
            
// in java/org/tigris/scarab/services/security/ldap/DummyCallbackHandler.java
public void handle(Callback[] callbacks) throws IOException,
			UnsupportedCallbackException {
		for (int i = 0; i < callbacks.length; i++) {
			if (callbacks[i] instanceof NameCallback) {
				((NameCallback) callbacks[i]).setName(username);
			} else if (callbacks[i] instanceof PasswordCallback) {
				((PasswordCallback) callbacks[i]).setPassword(password);
            } else if (callbacks[i] instanceof LDAPUserInfoCallback) {
                ldapUserInfo = (LDAPUserInfoCallback) callbacks[i];
			} else {
				throw new UnsupportedCallbackException(callbacks[i],
						"Callback class not supported");
			}
		}
	}
0 1 
            
// in java/org/tigris/scarab/services/security/ldap/DummyCallbackHandler.java
public void handle(Callback[] callbacks) throws IOException,
			UnsupportedCallbackException {
		for (int i = 0; i < callbacks.length; i++) {
			if (callbacks[i] instanceof NameCallback) {
				((NameCallback) callbacks[i]).setName(username);
			} else if (callbacks[i] instanceof PasswordCallback) {
				((PasswordCallback) callbacks[i]).setPassword(password);
            } else if (callbacks[i] instanceof LDAPUserInfoCallback) {
                ldapUserInfo = (LDAPUserInfoCallback) callbacks[i];
			} else {
				throw new UnsupportedCallbackException(callbacks[i],
						"Callback class not supported");
			}
		}
	}
1 
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}
1 
            
// in java/org/tigris/scarab/services/security/ldap/LdapLoginModule.java
catch (UnsupportedCallbackException e) {
			throw new LoginException(
					e.toString()
							+ "callbackHandler does not support name or password callback");
		}
0
runtime (Lib) UnsupportedOperationException 19 
            
// in java/org/tigris/scarab/om/MITList.java
public void remove()
        {
            List rawList = null;
            try
            {
                rawList = getMITListItems();
            }
            catch (TorqueException e)
            {
                throw new TorqueRuntimeException(e); //EXCEPTION
            }

            if (rawList.contains(currentObject))
            {
                rawList.remove(currentObject);
                i.remove();
                expandedList = null;
            }
            else
            {
                throw new UnsupportedOperationException(
                    "Removing items "
                        + "from a list containing wildcards is not supported."); //EXCEPTION
            }
        }
            
// in java/org/tigris/scarab/om/Query.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/Query.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/RModuleAttribute.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/RModuleOption.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/Issue.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/Issue.java
public void save(Connection dbCon)
        throws TorqueException
    {
        Module module = getModule();
        if (!module.allowsIssues() || (isNew() && !module.allowsNewIssues())) 
        {
            throw new UnsupportedOperationException(module.getName() + 
                " does not allow issues."); //EXCEPTION
        }
        
        // remove unset AttributeValues before saving
        List attValues = getAttributeValues();
        // reverse order since removing from list
        for (int i=attValues.size()-1; i>=0; i--) 
        {
            AttributeValue attVal = (AttributeValue) attValues.get(i);
            if (!attVal.isSet()) 
            {
                attValues.remove(i);
            }
        }

        if (isNew())
        {
            // set the issue id
            setIdDomain(module.getScarabInstanceId());
            setIdPrefix(module.getCode());

            // for an enter issue template, do not give issue id
            // set id count to -1 so does not show up as an issue
            if (isTemplate())
            { 
                setIdCount(-1);
            }
            else
            {
                try
                {
                    final int suggestedID = getIdCount();
                    if (suggestedID != 0) {
                        // Force the next available issue ID to be the
                        // nominated value, if not out of sequence.
                        // TODO: assert that this issue doesn't already exist
                        // In this case, just skip the next action.
                        setNextIssueId(dbCon, suggestedID);
                    }
                    
                    // Set the ID to the next available value.
                    setIdCount(getNextIssueId(dbCon));
                }
                catch (Exception e)
                {
                    throw new TorqueException(e); //EXCEPTION
                }
            }
        }
        if(  getActivitySetRelatedByLastTransId()==null
           ||getActivitySetRelatedByCreatedTransId()==null)
        {
            throw new RuntimeException("Created or Last ActivitySet must not be null.");
        }
        super.save(dbCon);
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void save()
    {
        throw new UnsupportedOperationException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void save(String dbName)
    {
        throw new UnsupportedOperationException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/AbstractScarabUser.java
public void save(Connection dbCon)
    {
        throw new UnsupportedOperationException("Not implemented"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/RModuleIssueType.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public ScarabModule getScarabModule()
    {
        throw new UnsupportedOperationException(
            "Should use getModule"); //EXCEPTION
    }
            
// in java/org/tigris/scarab/om/AttributeGroup.java
public void setScarabModule(ScarabModule module)
    {
        throw new UnsupportedOperationException(
            "Should use setModule(Module). Note module cannot be new."); //EXCEPTION
    }
            
// in java/org/tigris/scarab/services/cache/JCSScarabCacheService.java
public Map getMapImpl()
    {
        throw new UnsupportedOperationException(
        "'getMap' is not implemented");
    }
            
// in java/org/tigris/scarab/util/WindowIterator.java
public void remove()
    {
        throw new UnsupportedOperationException("'remove' is not implemented"); //EXCEPTION
    }
0 0 0 0 0
unknown (Domain) ValidationException 
public class ValidationException extends ScarabException
{
    /**
     * Constructs a new <code>ValidationException</code> with specified 
     * detail message.
     *
     * @param msg the error message.
     */
    public ValidationException(LocalizationKey l10nKey)
    {
        super(l10nKey);
    }

    /**
     * Constructs a new <code>ValidationException</code> with specified 
     * detail message.
     *
     * @param msg the error message.
     */
    public ValidationException(L10NMessage l10nMessage)
    {
        super(l10nMessage);
    }
 
    /**
     * Constructs a new <code>ValidationException</code> with specified 
     * detail message.
     *
     * @param msg the error message.
     */
    public ValidationException(L10NMessage l10nMessage, Throwable nested)
    {
        super(l10nMessage, nested);
    }
 
    /**
     * Constructs a new <code>ValidationException</code> with specified 
     * resource and a list of parameters.
     * @param theKey the l10n error key.
     */
    public ValidationException (LocalizationKey theKey, Object[] theParams)
    {
        super(theKey,theParams);
    }

    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and one parameter.
     * @param theKey the l10n error key.
     */
    public ValidationException (LocalizationKey theKey, Object p1)
    {
        this(theKey, new Object[] {p1});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and two parameters.
     * @param theKey the l10n error key.
     */
    public ValidationException (LocalizationKey theKey, Object p1, Object p2)
    {
        this(theKey, new Object[] {p1, p2});
    }
 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource and three parameters.
     * @param theKey the l10n error key.
     */
    public ValidationException(LocalizationKey theKey, Object p1, Object p2, Object p3)
    {
        this(theKey, new Object[] {p1, p2, p3});
    }

 
    /**
     * convenience constructor: Constructs a new <code>ScarabException</code>
     * with specified resource, nested Throwable and an aritrary set of parameters.
     * @param theKey the l10n error key.
     */
    public ValidationException(LocalizationKey theKey, Throwable nested, Object[] theParams)
    {
        super(theKey, nested, theParams);
    }
    
}
 		7 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
0 1 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
public void addIssueType(final IssueType issueType)
        throws TorqueException, ValidationException, DataSetException, ScarabException
    {
        // do some validation, refuse to add an issue type that is in a bad
        // state
        if (issueType == null) 
        {
            throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                    "NULL",
                    getName(),
                    "Issue type was null");
        }

        // check that the issueType is not already added.
        if (includesIssueType(issueType)) 
        {
            throw new ValidationException(L10NKeySet.ExceptionDuplicateIssueType,
                    issueType,
                    getName());
        }

        final String typeName = issueType.getName();
        // check attribute groups
        final List testGroups = issueType.getAttributeGroups(null, false);
        try
        {
            if (testGroups == null) 
            {
                final Localizable l10nMessage = new L10NMessage(L10NKeySet.IssueTypeWasNull);
                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                        typeName,
                        getName(),
                        l10nMessage);
            }
            else 
            {
                for (Iterator i = testGroups.iterator(); i.hasNext();)
                {
                    final AttributeGroup group = (AttributeGroup)i.next();
                    // check attributes
                    final List attrs = group.getAttributes();
                    if (attrs != null)
                    {
                        for (Iterator j = attrs.iterator(); j.hasNext();)
                        {
                            // check attribute-attribute group maps
                            final Attribute attr = (Attribute)j.next();
                            if (attr == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributesContainsNull);
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }                            
                            
                            // TODO: add workflow validation

                            final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                            if (raag == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                          
                            }

                            // check attribute-issue type maps
                            final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                            if (ria == null) 
                            {
                                final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.AttributeToIssueTypeMappingIsMissing, attr.getName());
                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                        typeName,
                                        getName(),
                                        l10nMessage);
                            }

                            // check options
                            final List rios = issueType.getRIssueTypeOptions(attr, false);
                            if (rios != null)
                            {
                                for (Iterator k=rios.iterator(); k.hasNext();)
                                {
                                    if (k.next() == null) 
                                    {
                                        final L10NMessage l10nMessage = new L10NMessage(L10NKeySet.ListOfOptionsMissing, attr.getName());
                                                throw new ValidationException(L10NKeySet.ExceptionIntegrityCheckFailure,
                                                typeName,
                                                getName(),
                                                l10nMessage);
                                    }
                                }
                            }
                        }
                    }
                }            
            }
        }
        catch (ValidationException ve)
        {
            throw ve;
        }
        catch (Exception e)
        {
            throw new ScarabException(
                    L10NKeySet.ExceptionGeneral, 
                    e.getMessage(),
                    e);
        }

        // okay we passed, start modifying tables

        // add module-issue type mapping
        final RModuleIssueType rmit = new RModuleIssueType();
        rmit.setModuleId(getModuleId());
        rmit.setIssueTypeId(issueType.getIssueTypeId());
        rmit.setActive(true);
        rmit.setDisplay(false);
        rmit.setOrder(getRModuleIssueTypes().size() + 1);
        rmit.setDedupe(issueType.getDedupe());
        rmit.save();

        // add user attributes
        final List userRIAs = issueType.getRIssueTypeAttributes(false, "user");
        for (int m=0; m<userRIAs.size(); m++)
        {
            final RIssueTypeAttribute userRia = (RIssueTypeAttribute)userRIAs.get(m);
            setRmaBasedOnIssueType(userRia);
        }

        // add workflow 
        WorkflowFactory.getInstance().addIssueTypeWorkflowToModule(this, issueType);

        // add attribute groups
        final List groups = issueType.getAttributeGroups(null, false);
        if (groups.isEmpty())
        {
            // Create default groups
            final AttributeGroup ag = createNewGroup(issueType);
            ag.setOrder(1);
            ag.setDedupe(true);
            ag.setDescription(null);
            ag.save();
            final AttributeGroup ag2 = createNewGroup(issueType);
            ag2.setOrder(3);
            ag2.setDedupe(false);
            ag2.setDescription(null);
            ag2.save();
        }
        else
        {            
            // Inherit attribute groups from issue type
            for (int i=0; i<groups.size(); i++)
            {
                final AttributeGroup group = (AttributeGroup)groups.get(i);
                final AttributeGroup moduleGroup = group.copyGroup();
                moduleGroup.setModuleId(getModuleId());
                moduleGroup.setIssueTypeId(issueType.getIssueTypeId());
                moduleGroup.save();

                // add attributes
                final List attrs = group.getAttributes();
                if (attrs != null)
                {
                    for (int j=0; j<attrs.size(); j++)
                    {
                        // save attribute-attribute group maps
                        final Attribute attr = (Attribute)attrs.get(j);
                        final RAttributeAttributeGroup raag = group.getRAttributeAttributeGroup(attr);
                        final RAttributeAttributeGroup moduleRaag = new RAttributeAttributeGroup();
                        moduleRaag.setAttributeId(raag.getAttributeId());
                        moduleRaag.setOrder(raag.getOrder());
                        moduleRaag.setGroupId(moduleGroup.getAttributeGroupId());
                        moduleRaag.save();

                        // save attribute-module maps
                        final RIssueTypeAttribute ria = issueType.getRIssueTypeAttribute(attr);
                        setRmaBasedOnIssueType(ria);

                        // save options
                        final List rios = issueType.getRIssueTypeOptions(attr, false);
                        if (rios != null)
                        {
                            for (int k=0; k<rios.size(); k++)
                            {
                                final RIssueTypeOption rio = (RIssueTypeOption)rios.get(k);
                                setRmoBasedOnIssueType(rio);
                            }
                        }
                    }
                }
            }
        }
    }
2 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException ve)
        {
            throw ve;
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
2 
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException ve)
        {
            throw ve;
        }
            
// in java/org/tigris/scarab/om/AbstractScarabModule.java
catch (ValidationException e)
                {
                    // if one issue type is bad, continue with the rest, if 
                    // more than one bad issue type is found, stop.
                    if (ve == null) 
                    {
                        ve = e;
                    }
                    else 
                    {
                        ve = new ValidationException(
                                L10NKeySet.ExceptionMultipleProblems,
                                ve.getMessage(),
                                e);//WORK: what about the stack trace ?
                        isInitializing = false;
                        throw ve;
                    }                    
                }
0

Miscellanous Metrics

nF = Number of Finally 18
nF = Number of Try-Finally (without catch) 10
Number of Methods with Finally (nMF) 15 / 3197 (0.5%)
Number of Finally with a Continue 0
Number of Finally with a Return 0
Number of Finally with a Throw 0
Number of Finally with a Break 0
Number of different exception types thrown 32
Number of Domain exception types thrown 6
Number of different exception types caught 47
Number of Domain exception types caught 4
Number of exception declarations in signatures 1985
Number of different exceptions types declared in method signatures 41
Number of library exceptions types declared in method signatures 38
Number of Domain exceptions types declared in method signatures 3
Number of Catch with a continue 2
Number of Catch with a return 36
Number of Catch with a Break 2
nbIf = Number of If 3196
nbFor = Number of For 542
Number of Method with an if 1248 / 3197
Number of Methods with a for 372 / 3197
Number of Method starting with a try 31 / 3197 (1%)
Number of Expressions 43913
Number of Expressions in try 5459 (12.4%)