Class UsersProviderBase

Archive provider for the list of users in SoAdmin, including dynamic license columns

Inheritance
object
ExtensibleColumnsBase
QueryProviderBaseArchiveRow
TypedQueryProviderBaseArchiveRowAssociateAssociateExtender
UsersProviderBase
AllUsersProvider
ExternalUsersProvider
InternalUsersProvider
OtherUsersProvider
Inherited Members
Namespace: SuperOfficeCRMArchiveLists
Assembly: SoDataBase.BusinessLogic.dll
Syntax
public abstract class UsersProviderBase : TypedQueryProviderBase<ArchiveRow, AssociateAssociateExtender>, IArchiveProviderQueryMapping, IArchiveQueryProvider, IArchiveProviderExtensible, IArchiveTypedProvider<ArchiveRow>, IArchiveTypedProviderBase, IArchiveProvider, IArchiveProviderHasRows, IArchiveProviderHasColumns, IArchiveProviderHasEntities
Remarks

This system provides all the standard columns from the AssociateExtenderBase, as well as one dynamically generated column per module license present. Module licenses are filtered so that only type User, with nonzero amount or unrestricted, are taken into account.

For each such module license, a column named <ownerName>_<moduleName> is created and made available; this is an Icon column with an Int32 raw value (0 or 1). A row type with the same name is also created. All of them have reasonable display names etc.

Row types work as a filter with implicit "OR". If you ask for row types superoffice_travel and superoffice_publish, and request the column superoffice_web, you will get rows for all associates that have EITHER the travel OR publish license (or both); and you will see if each one has the web CAL.

The special rowtype "all" will turn off row filtering. Regardless of this, you can always set a contactId restriction, and choose any combination of columns.

The special rowtype "expired" will filter rows so that only users with at least one expired license will show.

Note that this is a base class. Concrete subclasses implement FilterAssocTypes to tell the base class what kind of associates should be processed (internal, external, other, ...). This simply applies filtering to both licenses and associates - the rest of the functionality is the same.

Constructors

UsersProviderBase()

Declaration
protected UsersProviderBase()

Fields

RowTypeAllName

Declaration
public const string RowTypeAllName = "all"
Field Value
Type Description
string

RowTypeExpiredName

Declaration
public const string RowTypeExpiredName = "expired"
Field Value
Type Description
string

RowTypeLoggedOnWin

Declaration
public const string RowTypeLoggedOnWin = "loggedOnWin"
Field Value
Type Description
string

RowTypePotentialName

Declaration
public const string RowTypePotentialName = "potential"
Field Value
Type Description
string

RowTypeRetired

Declaration
public const string RowTypeRetired = "retired"
Field Value
Type Description
string

_colCanLogin

Declaration
protected ArchiveColumnInfo _colCanLogin
Field Value
Type Description
ArchiveColumnInfo

_colUserplan

Declaration
protected ArchiveColumnInfo _colUserplan
Field Value
Type Description
ArchiveColumnInfo

Properties

FilterAssocTypes

Subclass contract: Tell us which associate types you want to deal with; this will influence what licenses are retrieved

Declaration
protected abstract UserType[] FilterAssocTypes { get; }
Property Value
Type Description
SuperOffice.License.UserType

FilterColumns

Subclass contract: Tell us if there are any columns that you want to filter out

Declaration
protected virtual string[] FilterColumns { get; }
Property Value
Type Description
string

InhibitDistinctPrimaryKeys

Override this property and return TRUE if you wish to disable the check for distinct primary keys. This will save some time and space, at the cost of potential duplicate rows that would otherwise have been discarded

Declaration
public override bool InhibitDistinctPrimaryKeys { get; }
Property Value
Type Description
bool
Overrides

Methods

AcceptRow(SoDataReader)

Accept only those associates that have at least one of the desired rowtype licenses

Declaration
protected override bool AcceptRow(SoDataReader reader)
Parameters
Type Name Description
SoDataReader reader
Returns
Type Description
bool
Overrides

GetAvailableColumns()

Override: Get rid of available columns that the concrete class says it does not want/support

Declaration
public override List<ArchiveColumnInfo> GetAvailableColumns()
Returns
Type Description
ListArchiveColumnInfo
Overrides

InnerMapFieldsAsync(CancellationToken)

Base class handles all standard columns. Our functionality is to determine which modules we're interested in (sum of desired columns and row types), and populate the licenses-per-associate cache

Declaration
public override Task InnerMapFieldsAsync(CancellationToken cancellationToken = default)
Parameters
Type Name Description
CancellationToken cancellationToken
Returns
Type Description
Task
Overrides

InnerPopulateRowFromReader(SoDataReader, ArchiveRow)

Populate dynamic columns according to the cached who-has-which-license (SuperOffice.CRM.ArchiveLists.UsersProviderBase._assocLicenses)

Declaration
protected override void InnerPopulateRowFromReader(SoDataReader reader, ArchiveRow row)
Parameters
Type Name Description
SoDataReader reader
ArchiveRow row
Overrides

PostProcessQuery()

Manipulate the query according to various rules and filters

Declaration
public override void PostProcessQuery()
Overrides
Remarks
  1. Only get associate records of the correct type (if we're getting associates, that is)
    2a) Flip the master table from associate to person, if we're looking at potential persons
    2b) In that case, and if no contact has been specified, and if we're looking for internal users, then also restrict to persons that belong to contacts who are in ownercontactlink
  2. Get hold of the correct person table instance
  3. If we're only looking at logged-on users, then add the inner join for activeuser; otherwise add an outer join
  4. If we want retired users, then restrict for that
    There is a fair amount of query and join manipulation here, and more than one new method was written in the Select, Join etc classes to make it less ugly.

RequiredPhaseOneFields()

Return the FieldInfo fields needed by AcceptRow(SoDataReader), so that the query rewriter does not drop them. Implement this method IFF you implement AcceptRow.

Declaration
protected override FieldInfo[] RequiredPhaseOneFields()
Returns
Type Description
FieldInfo
Overrides

SetDesiredEntities(params string[])

Prune the desired row types dictionary so it only contains elements corresponding to desired entities

Declaration
public override void SetDesiredEntities(params string[] entities)
Parameters
Type Name Description
string entities
Overrides

SetRestriction(params ArchiveRestrictionInfo[])

Override: Determine if a contact_id restriction is present, in which case we do not add a join to ownercontactlink for potential users

Declaration
public override bool SetRestriction(params ArchiveRestrictionInfo[] restrictions)
Parameters
Type Name Description
ArchiveRestrictionInfo restrictions
Returns
Type Description
bool
Overrides

Implements

Extension Methods