Class LiteralsOnlyBase
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Inheritance
Namespace: SuperOffice.CRM.Lists
Assembly: SoDataBase.dll
Syntax
public abstract class LiteralsOnlyBase : Object, ISoListProvider, ISoList, IPluginConstructors
LiteralsOnlyBase()
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected LiteralsOnlyBase()Properties
ExtraInfo
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected string ExtraInfo { get; }Property Value
| Type | Description |
|---|---|
| String |
ForceFlatList
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected bool ForceFlatList { get; }Property Value
| Type | Description |
|---|---|
| Boolean |
HeadingItems
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
public List<ISoListHeading> HeadingItems { get; }Property Value
| Type | Description |
|---|---|
| List<ISoListHeading> |
HistoryIds
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected int[] HistoryIds { get; }Property Value
| Type | Description |
|---|---|
| Int32[] |
HistoryInfo
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
public HistoryInfo HistoryInfo { get; }Property Value
| Type | Description |
|---|---|
| HistoryInfo |
HistoryItems
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
public List<ISoListItem> HistoryItems { get; }Property Value
| Type | Description |
|---|---|
| List<ISoListItem> |
ListName
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected string ListName { get; }Property Value
| Type | Description |
|---|---|
| String |
OnlyReadHistory
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected bool OnlyReadHistory { get; }Property Value
| Type | Description |
|---|---|
| Boolean |
RawHeadingItems
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected List<ISoListHeading> RawHeadingItems { get; }Property Value
| Type | Description |
|---|---|
| List<ISoListHeading> |
RawHistoryItems
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected List<ISoListItem> RawHistoryItems { get; }Property Value
| Type | Description |
|---|---|
| List<ISoListItem> |
RawRootItems
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected List<ISoListItem> RawRootItems { get; }Property Value
| Type | Description |
|---|---|
| List<ISoListItem> |
RootItems
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
public List<ISoListItem> RootItems { get; }Property Value
| Type | Description |
|---|---|
| List<ISoListItem> |
SearchValue
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
protected string SearchValue { get; set; }Property Value
| Type | Description |
|---|---|
| String |
Methods
AddItems()
Subclass contract: use the RawRootItems and RawHeadingItems properties to add items to your literals-only list. The base class will then perform any search or flattening required.
Declaration
protected abstract void AddItems()Remarks
Lists that only contain literals can be either flat or grouped. If you create a grouped list and the caller specifies a forceFlatList attribute, the base class will do the flattening for you.
Examples
This example shows a typical implementation of a literal list, in this case the date interval list from the Filter dialog:
[MDOProviderPlugin( "FilterFutureDate" )]
public class FilterFutureDateList : LiteralsOnlyBase
{
protected override void AddItems()
{
RawRootItems.Add( new SoListItem( 1, "[SR_DATE_RANGE_3MONTHS]", string.Empty, string.Empty ) );
RawRootItems.Add( new SoListItem( 2, "[SR_DATE_RANGE_4MONTHS]", string.Empty, string.Empty ) );
RawRootItems.Add( new SoListItem( 3, "[SR_DATE_RANGE_6MONTHS]", string.Empty, string.Empty ) );
RawRootItems.Add( new SoListItem( 4, "[SR_DATE_RANGE_1YEAR]", string.Empty, string.Empty ) );
RawRootItems.Add( new SoListItem( 5, "[SR_DATE_RANGE_2YEAR]", string.Empty, string.Empty ) );
}
}Note that using a search in this case yields unexpected results. The search is performed on the raw items, which contains resource tags - and that is not what you actually want to search against. So resources + search do not go together.
AddRawRootEnum<TEnum>(TEnum, String, Boolean)
A helper method for adding items to RawRootItems
Declaration
protected void AddRawRootEnum<TEnum>(TEnum enumValue, string name, bool deleted = false)
where TEnum : EnumParameters
| Type | Name | Description |
|---|---|---|
| TEnum | enumValue | The enum value to be used for item ID |
| String | name | Name of an item |
| Boolean | deleted | if true, don't show in lists unless actually specified |
Type Parameters
| Name | Description |
|---|---|
| TEnum | The enum type the provider values represent |
Construct(String, String, Int32[], Boolean, String, Boolean)
Base class for making So List providers that represent one single, hard-coded list, i.e., a list where all the items are hard coded and known at compile or run time. Generally, items do not come from the database, though that would always be possible. See the AddItems() method for an example subclass implementation.
Declaration
public virtual void Construct(string listName, string additionalInfo, int[] historyIDs, bool onlyReadHistory, string searchValue, bool forceFlatList)Parameters
| Type | Name | Description |
|---|---|---|
| String | listName | |
| String | additionalInfo | |
| Int32[] | historyIDs | |
| Boolean | onlyReadHistory | |
| String | searchValue | |
| Boolean | forceFlatList |