public ConditionGroup(Guid guid, IPolicyLanguageItem name, ConditionLogic logic, bool exitOnFirstPass)
: base(guid, name)
{
m_logic = logic;
m_exitOnFirstPass = exitOnFirstPass;
m_conditions = new PolicyObjectCollection<IPolicyObject>();
}
/// <summary>
/// Setup constructor
/// </summary>
/// <param name="policyType">Associated policy type</param>
/// <param name="name">Policy type display name</param>
/// <param name="channels">Policy type channels</param>
/// <param name="available">If policy type is available to be used in the designer</param>
public PolicyTypeInfo(PolicyType policyType, IPolicyLanguageItem name, ChannelType[] channels, bool available)
{
m_PolicyType = policyType;
m_Name = name;
m_Channels = channels;
m_Available = available;
}
public PolicyCatalogue(Guid identifier, Guid languageId, IPolicyLanguageItem name, IPolicyCatalogueStore catalogueStore, bool readOnly)
: base(identifier, name, readOnly)
{
m_catalogueReader = catalogueStore.GetReader(identifier);
m_languageId = languageId;
catalogueStore.AddPolicyCatalogue(this);
}
public PolicySet(PolicyType type, Guid guid, IPolicyLanguageItem name, IPolicyStore policyStore, IPolicyCatalogue policyCatalogue, bool readOnly)
: base(guid, name, readOnly)
{
m_type = type;
m_policyStore = policyStore;
m_masterCatalogue = policyCatalogue;
(m_masterCatalogue as PolicyCatalogue).PolicySet = this;
}
public static void AddLanguageItemAttribute(XmlNode parentNode, string name, IPolicyLanguageItem languageItem)
{
if (typeof(NonTranslateableLanguageItem) == languageItem.GetType())
{
AddAttribute(parentNode, name, languageItem.Value);
}
else
{
AddAttribute(parentNode, name, languageItem.Identifier);
}
}
public NxParameter(string name, IPolicyLanguageItem languageItem)
{
m_name = name;
if (languageItem is TranslateableLanguageItem)
{
m_value = languageItem.Identifier.ToString();
m_IsValueId = true;
}
else
{
NonTranslateableLanguageItem ntli = languageItem as NonTranslateableLanguageItem;
m_value = ntli.Value;
m_IsValueId = false;
}
}
public static DataItem CreateDataItemWithCultureInfo(IPolicyLanguageItem name, DataType dataType, object data, CultureInfo ci)
{
switch (dataType)
{
case DataType.StringArray:
case DataType.String:
return new DataItem(name, Convert.ToString(data, ci));
case DataType.LongArray:
case DataType.Long:
return new DataItem(name, Convert.ToInt64(data, ci));
case DataType.DoubleArray:
case DataType.Double:
return new DataItem(name, Convert.ToDouble(data, ci));
case DataType.BooleanArray:
case DataType.Boolean:
return new DataItem(name, Convert.ToBoolean(data, ci));
case DataType.DateArray:
case DataType.Date:
case DataType.DateTimeArray:
case DataType.DateTime:
return new DataItem(name, Convert.ToDateTime(data, ci));
case DataType.Object:
{
DataSource dataSource = data as DataSource;
return new DataItem(name, dataSource.DeepCopy(dataSource.ReadOnly, false));
}
default:
{
ErrorMessage errorMessage = new ErrorMessage(
"OUT_OF_RANGE",
"Workshare.Policy.Properties.Resources",
Assembly.GetExecutingAssembly(), dataType);
Logger.LogError(errorMessage.LogString);
throw new PolicyException(errorMessage.DisplayString);
}
}
}
public PolicyObject(Guid guid, IPolicyLanguageItem name)
{
SetDefaults(guid, name, false);
}
private void SetDefaults(Guid guid, IPolicyLanguageItem name, bool readOnly)
{
m_identifier = guid;
Name = name;
m_readOnly = readOnly;
m_attributes = new Dictionary<string, IPolicyLanguageItem>();
SetLocalContext();
}
/// <summary>
/// Creates a DataItem object intialised with the supplied data.
/// </summary>
/// <param name="name">The name of the DataItem</param>
/// <param name="dataType">The type of data held by the DataItem</param>
/// <param name="data">The value of the DataItem. This should be either an object of the appropriate data type, or the invariant culture string representation of that object</param>
/// <returns>The instantiated DataItem</returns>
/// <remarks>Throws a FormatException if the data cannot be converted to the appropriate type</remarks>
public static DataItem CreateDataItem(IPolicyLanguageItem name, DataType dataType, object data)
{
return CreateDataItemWithCultureInfo(name, dataType, data, CultureInfo.InvariantCulture);
}
public Action(Guid identifier, IPolicyLanguageItem name, string assembly, string className, RunAt runAtMode, bool overrideMode, int precedence)
: base(identifier, name)
{
SetDefaults(assembly, className, runAtMode, overrideMode, precedence, false);
}
public DataElement(IPolicyLanguageItem name, IPolicyLanguageItem displayname, DataType dataType, object data)
: base(Guid.NewGuid(), name)
{
SetDefaults(dataType, data, displayname, false);
}
private void SetDefaults(DataType dataType, object data, IPolicyLanguageItem displayname, bool createNewId)
{
new DataTypeValidator(dataType, data).Validate();
m_type = dataType;
m_data = data;
m_displayname = createNewId ? displayname.Clone() : displayname;
}
/// <summary>
/// Loads a Channel object from the data source
/// </summary>
/// <param name="name"></param>
/// <param name="type"></param>
public Channel(Guid guid, IPolicyLanguageItem name, ChannelType type)
: base(guid, name)
{
SetType(type);
}
public PolicyChannel(Guid guid, IPolicyLanguageItem name, ChannelType type, bool readOnly)
: base(guid, name, type, readOnly)
{
}
/// <summary>
/// Constructs a new Rule object as a NEW object
/// </summary>
/// <param name="name"></param>
/// <param name="status"></param>
public CataloguePolicy(Guid guid, IPolicyLanguageItem name, PolicyStatus status, bool readOnly)
: base(guid, name, readOnly)
{
m_status = status;
}
/// <summary>
/// Constructs a new Rule object as a NEW object
/// </summary>
/// <param name="name"></param>
/// <param name="status"></param>
public CataloguePolicy(Guid guid, IPolicyLanguageItem name, PolicyStatus status)
: base(guid, name)
{
m_status = status;
}
protected void SetDefaults(IPolicyLanguageItem description, IPolicyLanguageItem color, int precedence)
{
Description = description;
Color = color;
m_precedence = precedence;
}
public RoutingMatrixCell(IPolicyLanguageItem name, IPolicyLanguageItem description, IPolicyLanguageItem color, int precedence, bool readOnly, IRoutingItemCollection senders, IRoutingItemCollection recipients)
: base(Guid.Empty, name, readOnly, senders, recipients)
{
SetDefaults(description, color, precedence);
}
public PolicyObject(Guid guid, IPolicyLanguageItem name, bool readOnly)
{
SetDefaults(guid, name, readOnly);
}
public NonTranslateableLanguageItem(IPolicyLanguageItem value)
{
m_value = value.Value;
}
public Condition(Guid guid, string className, IPolicyLanguageItem name, OperatorType operatorType)
: this(guid, className, name, operatorType, false)
{
}
public Channel(Guid guid, IPolicyLanguageItem name, ChannelType type, bool readOnly)
: base(guid, name, readOnly)
{
SetType(type);
}
public PolicyChannel(Guid guid, IPolicyLanguageItem name, ChannelType type)
: base(guid, name, type)
{
}
public DataElement(Guid guid, IPolicyLanguageItem name, IPolicyLanguageItem displayname, DataType dataType, object data, bool readOnly)
: base(guid, name, readOnly)
{
SetDefaults(dataType, data, displayname, false);
}
public OfflineRoutingMatrixCell(IPolicyLanguageItem name, IPolicyLanguageItem description, IPolicyLanguageItem color, int precedence, bool readOnly)
: base(name, description, color, precedence, readOnly, null, null)
{
}
public MatrixCellBase(Guid guid, IPolicyLanguageItem name, bool readOnly, IRoutingItemCollection sources, IRoutingItemCollection destinations)
:base(guid, name, readOnly)
{
m_sources = sources;
m_destinations = destinations;
}
public DataMethod(string name)
{
m_name = new NonTranslateableLanguageItem(name);
m_parameters = new PolicyObjectCollection<IParameter>();
}
public Condition(Guid guid, string className, IPolicyLanguageItem name, OperatorType operatorType, bool readOnly)
: base(guid, name, readOnly)
{
SetDefaults(className, operatorType, null, false);
}
private DataItem(IPolicyLanguageItem name, object value)
: base(Guid.NewGuid(), name)
{
m_value = value;
}
