Namespace LemonEdge.API.Core

Classes

BaseEntity

The base class that every system implementation of IBaseEntity inherits from

BaseEntityCloneContext

The context that is used with SetItemInfo and ICloneableAsync copying items

BaseEntityWithPermissions

Every entity that requires its own permissions must implement IBaseEntityWithPermissions

You don't have to inherit from this class necessarily, you can implement your own base class

This does contain some static helper functions for working with permissions

EntityKeyComparer

Implements the System.Collections.Generic.IEqualityComparer<T> for all IBaseEntity. Compares on type, canvas and ID

EntityKeyComparer<T>

Implements the System.Collections.Generic.IEqualityComparer<T> for a specific type T that implements IBaseEntity. Compares on canvas and ID

License

The class that is serialized and hashed to check for a valid license

UserExtensions

A set of extensions for help with UserInfo

UserInfo

The light user info class that holds the relevant information for the current logged in user, or user that processes/tasks are running under

Interfaces

IBaseEntity

This is the base interface all entities within LemonEdge must implement.

All the properties on this base interface are implemented by *every* entity in LemonEdge, and thus exist as columns for every table in the database

IBaseEntityWithPermissions

Any entity that needs its own permissions needs to inherits from this interface rather than IBaseEntity

This ensures the system creates appropriate permissions table for this entity, and that individual records can be assigned permissions

If an entity does not inherit from this then it should inherit permissions from another entity through a relationship (InheritPermissions). If it does not then the entity will effectively have full permissions for every user as it will have no permissions, inherited or otherwise.

ICanBeLocked

Indicates this entity can be locked. The system enforces locked items in the core and ensures they can not be modified when they are marked as locked.

For example, transactions use this to lock them when they are finalized or cancelled

ICanBeTransfered

Indicates this item contains values relevant to ultimate owner through allocation paths and should be transferred as part of the transfer processing logic

See ITransfer for more information

IHasOriginalID

Indicates this entity can be copied from other entities, and when done so this holds the id of the original item it was copied from

IHasSaveProcessingTask

Indicates this entity when saved can create an associated task to finish processing the save.

This task is created during the save by a processor implementing IBaseDataSetProcessorWithDBSave

See BaseTransactionProcessor for more info

This is used by a client to notice that although the save is complete, a task has been automatically created for processing the rest of this task, and it can track that task for final completion. When the task is completing one of the steps is to set this back to null.

IHeaderTransactionalEntity

Certain types of transactions are root transction headers. They represent the root record, such as a ITransfer record, and other transactional records are children of it (such as ITransferEntityOverride) but are not root records

The root record has a uniquely identifiable reference for the user, along with other header information

ILicense

Indicates this entity holds all the values required for a valid license of the LemonEdge platform

The License class is the actual class that is serialized and hashed for a license validity check. It also implements this interface.

The system implementation of this for users to create licenses is through IAccountMaintenance

IShareAcrossAccounts

Indicates this entity is one that can be shared accross multi-tenanted accounts in the same database.

This is used for configuration such as addins IAddInModule, and custom objects ICustomObject.

Only the root account (ID=1) can edit items that are shared items across acounts

ITransactionalEntity

Indicates this entity is a transaction entity, and can be cancelled/corrected by our core transaction processing logic.

The BaseTransactionProcessor provides all the common transaction processing logic based on entities from IHeaderTransactionalEntity and this interface

IWrapper

Indicates this item wraps another entity, held by WrappedItem

This is used for entities that want to display a pivot of options within a grid. The logic for this is all taken care of using this and EntityHasPivotAttribute

See IGLAccount for an example

Enums

LicenseType

The type of license.

If you have an invalid, or unlicensed product, you are not authorized to be using the platform and will be prosecuted to the maximum extand allowable under the law.

TransactionStatus

The status of a ITransactionalEntity