Show / Hide Table of Contents

Class ProductRow

One Product, member of one price list
Row Object for table 'Product'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Inheritance
object
SqlCommand
PrivateSave
TableRowBase
ProductRow
Implements
INestedPersist
ISoDataLookup
ISentryIgnorable
Inherited Members
TableRowBase._saveOwner
TableRowBase._sentries
TableRowBase._relatedNestedPersistMembers
TableRowBase._isSaving
TableRowBase._sqlType
TableRowBase.InternalSetValue(int, object)
TableRowBase.InternalSetValue(SoField, object)
TableRowBase.GetFieldValue(FieldInfo)
TableRowBase.GetKnownFields()
TableRowBase.IsGhostField(FieldInfo)
TableRowBase.RowLoad()
TableRowBase.RowLoadAsync(ITableRowLoadHandler, CancellationToken)
TableRowBase.OnLoaded(IdxBase)
TableRowBase.Load(IdxBase, SoDataReader)
TableRowBase.Load(SoDataReader, TableInfo)
TableRowBase.SetDefaultsAsync(CancellationToken)
TableRowBase.SetDefaultsAsync(DashboardTileDefinitionRow, string, CancellationToken)
TableRowBase.SetSaveOwner(INestedPersist)
TableRowBase.GetForeignKeyHelperAsync(CancellationToken)
TableRowBase.SaveAsync()
TableRowBase.DeleteAsync()
TableRowBase.Validate()
TableRowBase.SetDirty(int, object, object)
TableRowBase.OnPreIdUpdateAsync()
TableRowBase.OnPrimaryKeyRequestAsync(PKContainer)
TableRowBase.OnPrimaryKeyUpdateAsync(PKContainer)
TableRowBase.OnIdUpdateAsync()
TableRowBase.BeginIgnoreSentryCheck()
TableRowBase.EndIgnoreSentryCheck()
TableRowBase.GetRelatedNestedPersist()
TableRowBase.RowLoad(ITableRowLoadHandler)
TableRowBase.this[int]
TableRowBase.this[SoField]
TableRowBase.Sentries
TableRowBase.IsDeleted
TableRowBase.IsSaving
TableRowBase.SqlType
TableRowBase.IsSentryIgnored
TableRowBase.IsMarkedForDelete
TableRowBase.OnElementSaved
TableRowBase.OnElementIdUpdate
PrivateSave.GetTableInfos()
PrivateSave.CloneToBasicUpdatingQuery()
PrivateSave.SetTicketLogAction(TicketLogAction, string)
PrivateSave.DoNotWriteTraveltransactionLog
PrivateSave.OnUpdateField
SqlCommand.Origin
SqlCommand.AdditionalInfo
SqlCommand.AddIgnoreAutoSentryTableInfo(TableInfo)
SqlCommand.AddIgnoreAutoSentryTableInfo(IEnumerable<TableInfo>)
SqlCommand.RemoveIgnoreAutoSentryTableInfo(TableInfo)
SqlCommand.ClearIgnoreAutoSentryTableInfos()
SqlCommand.IsAutoSentryIgnoredOnTableInfo(TableInfo)
SqlCommand.GetPrivateSaves()
SqlCommand.GetInserts()
SqlCommand.GetUpdates()
SqlCommand.GetDeletes()
SqlCommand.GetSelect()
SqlCommand.AutoSentryIgnoredTables
object.Equals(object)
object.Equals(object, object)
object.ReferenceEquals(object, object)
object.GetHashCode()
object.GetType()
object.MemberwiseClone()
Namespace: SuperOffice.CRM.Rows
Assembly: SoDataBase.dll
Syntax
public class ProductRow : TableRowBase, INestedPersist, ISoDataLookup, ISentryIgnorable
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

Constructors

ProductRow(ProductRowIdxBase)

Constructor for the class taking an index as argument. One Product, member of one price list

Declaration
protected ProductRow(ProductRow.ProductRowIdxBase idx)
Parameters
Type Name Description
ProductRow.ProductRowIdxBase idx

The index representing a SELECT command to the database.

Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

Fields

_currentCode

Current value, see property Code.

Declaration
protected string _currentCode
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentDefaultSubscriptionQuantity

Current value, see property DefaultSubscriptionQuantity.

Declaration
protected double _currentDefaultSubscriptionQuantity
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentDescription

Current value, see property Description.

Declaration
protected string _currentDescription
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentERPProductKey

Current value, see property ERPProductKey.

Declaration
protected string _currentERPProductKey
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentExtraField1

Current value, see property ExtraField1.

Declaration
protected string _currentExtraField1
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentExtraField2

Current value, see property ExtraField2.

Declaration
protected string _currentExtraField2
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentExtraField3

Current value, see property ExtraField3.

Declaration
protected string _currentExtraField3
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentExtraField4

Current value, see property ExtraField4.

Declaration
protected string _currentExtraField4
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentExtraField5

Current value, see property ExtraField5.

Declaration
protected string _currentExtraField5
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentExtraInfo

Current value, see property ExtraInfo.

Declaration
protected string _currentExtraInfo
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentInAssortment

Current value, see property InAssortment.

Declaration
protected short _currentInAssortment
Field Value
Type Description
short
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentIsSubscription

Current value, see property IsSubscription.

Declaration
protected short _currentIsSubscription
Field Value
Type Description
short
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentItemNumber

Current value, see property ItemNumber.

Declaration
protected string _currentItemNumber
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentName

Current value, see property Name.

Declaration
protected string _currentName
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentPriceListId

Current value, see property PriceListId.

Declaration
protected int _currentPriceListId
Field Value
Type Description
int
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentPriceUnit

Current value, see property PriceUnit.

Declaration
protected string _currentPriceUnit
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentProductCategoryKey

Current value, see property ProductCategoryKey.

Declaration
protected string _currentProductCategoryKey
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentProductFamilyKey

Current value, see property ProductFamilyKey.

Declaration
protected string _currentProductFamilyKey
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentProductId

Current value, see property ProductId.

Declaration
protected int _currentProductId
Field Value
Type Description
int
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentProductTypeKey

Current value, see property ProductTypeKey.

Declaration
protected string _currentProductTypeKey
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentQuantityUnit

Current value, see property QuantityUnit.

Declaration
protected string _currentQuantityUnit
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentRegistered

Current value, see property Registered.

Declaration
protected DateTime _currentRegistered
Field Value
Type Description
DateTime
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentRegisteredAssociateId

Current value, see property RegisteredAssociateId.

Declaration
protected int _currentRegisteredAssociateId
Field Value
Type Description
int
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentRights

Current value, see property Rights.

Declaration
protected string _currentRights
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentRule

Current value, see property Rule.

Declaration
protected string _currentRule
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentSubscriptionUnit

Current value, see property SubscriptionUnit.

Declaration
protected string _currentSubscriptionUnit
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentSupplier

Current value, see property Supplier.

Declaration
protected string _currentSupplier
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentSupplierCode

Current value, see property SupplierCode.

Declaration
protected string _currentSupplierCode
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentUnitCost

Current value, see property UnitCost.

Declaration
protected double _currentUnitCost
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentUnitListPrice

Current value, see property UnitListPrice.

Declaration
protected double _currentUnitListPrice
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentUnitMinimumPrice

Current value, see property UnitMinimumPrice.

Declaration
protected double _currentUnitMinimumPrice
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentUpdated

Current value, see property Updated.

Declaration
protected DateTime _currentUpdated
Field Value
Type Description
DateTime
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentUpdatedAssociateId

Current value, see property UpdatedAssociateId.

Declaration
protected int _currentUpdatedAssociateId
Field Value
Type Description
int
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentUpdatedCount

Current value, see property UpdatedCount.

Declaration
protected short _currentUpdatedCount
Field Value
Type Description
short
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentUrl

Current value, see property Url.

Declaration
protected string _currentUrl
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentVAT

Current value, see property VAT.

Declaration
protected double _currentVAT
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_currentVATInfo

Current value, see property VATInfo.

Declaration
protected string _currentVATInfo
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedCode

Persisted value, see property Code.

Declaration
protected string _persistedCode
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedDefaultSubscriptionQuantity

Persisted value, see property DefaultSubscriptionQuantity.

Declaration
protected double _persistedDefaultSubscriptionQuantity
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedDescription

Persisted value, see property Description.

Declaration
protected string _persistedDescription
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedERPProductKey

Persisted value, see property ERPProductKey.

Declaration
protected string _persistedERPProductKey
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedExtraField1

Persisted value, see property ExtraField1.

Declaration
protected string _persistedExtraField1
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedExtraField2

Persisted value, see property ExtraField2.

Declaration
protected string _persistedExtraField2
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedExtraField3

Persisted value, see property ExtraField3.

Declaration
protected string _persistedExtraField3
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedExtraField4

Persisted value, see property ExtraField4.

Declaration
protected string _persistedExtraField4
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedExtraField5

Persisted value, see property ExtraField5.

Declaration
protected string _persistedExtraField5
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedExtraInfo

Persisted value, see property ExtraInfo.

Declaration
protected string _persistedExtraInfo
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedInAssortment

Persisted value, see property InAssortment.

Declaration
protected short _persistedInAssortment
Field Value
Type Description
short
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedIsSubscription

Persisted value, see property IsSubscription.

Declaration
protected short _persistedIsSubscription
Field Value
Type Description
short
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedItemNumber

Persisted value, see property ItemNumber.

Declaration
protected string _persistedItemNumber
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedName

Persisted value, see property Name.

Declaration
protected string _persistedName
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedPriceListId

Persisted value, see property PriceListId.

Declaration
protected int _persistedPriceListId
Field Value
Type Description
int
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedPriceUnit

Persisted value, see property PriceUnit.

Declaration
protected string _persistedPriceUnit
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedProductCategoryKey

Persisted value, see property ProductCategoryKey.

Declaration
protected string _persistedProductCategoryKey
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedProductFamilyKey

Persisted value, see property ProductFamilyKey.

Declaration
protected string _persistedProductFamilyKey
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedProductId

Persisted value, see property ProductId.

Declaration
protected int _persistedProductId
Field Value
Type Description
int
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedProductTypeKey

Persisted value, see property ProductTypeKey.

Declaration
protected string _persistedProductTypeKey
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedQuantityUnit

Persisted value, see property QuantityUnit.

Declaration
protected string _persistedQuantityUnit
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedRegistered

Persisted value, see property Registered.

Declaration
protected DateTime _persistedRegistered
Field Value
Type Description
DateTime
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedRegisteredAssociateId

Persisted value, see property RegisteredAssociateId.

Declaration
protected int _persistedRegisteredAssociateId
Field Value
Type Description
int
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedRights

Persisted value, see property Rights.

Declaration
protected string _persistedRights
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedRule

Persisted value, see property Rule.

Declaration
protected string _persistedRule
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedSubscriptionUnit

Persisted value, see property SubscriptionUnit.

Declaration
protected string _persistedSubscriptionUnit
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedSupplier

Persisted value, see property Supplier.

Declaration
protected string _persistedSupplier
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedSupplierCode

Persisted value, see property SupplierCode.

Declaration
protected string _persistedSupplierCode
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedUnitCost

Persisted value, see property UnitCost.

Declaration
protected double _persistedUnitCost
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedUnitListPrice

Persisted value, see property UnitListPrice.

Declaration
protected double _persistedUnitListPrice
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedUnitMinimumPrice

Persisted value, see property UnitMinimumPrice.

Declaration
protected double _persistedUnitMinimumPrice
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedUpdated

Persisted value, see property Updated.

Declaration
protected DateTime _persistedUpdated
Field Value
Type Description
DateTime
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedUpdatedAssociateId

Persisted value, see property UpdatedAssociateId.

Declaration
protected int _persistedUpdatedAssociateId
Field Value
Type Description
int
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedUpdatedCount

Persisted value, see property UpdatedCount.

Declaration
protected short _persistedUpdatedCount
Field Value
Type Description
short
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedUrl

Persisted value, see property Url.

Declaration
protected string _persistedUrl
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedVAT

Persisted value, see property VAT.

Declaration
protected double _persistedVAT
Field Value
Type Description
double
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

_persistedVATInfo

Persisted value, see property VATInfo.

Declaration
protected string _persistedVATInfo
Field Value
Type Description
string
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

Properties

Code

.NET type: string. The product code / article number in the product supplier system.

Declaration
public virtual string Code { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

DefaultSubscriptionQuantity

.NET type: double. The default number of SubscriptionUnits to suggest when creating quote lines from this product

Declaration
public virtual double DefaultSubscriptionQuantity { get; set; }
Property Value
Type Description
double
Remarks

Original type in dictionary: Double.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Description

.NET type: string. The description to use, with potentially several lines. Will be used as tool-tip to use in the list user interface too.

Declaration
public virtual string Description { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[2048].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ERPProductKey

.NET type: string. Reference/foreign key to the product in the given pricelist in the product supplier system, if it exists there.

Declaration
public virtual string ERPProductKey { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ExtraField1

.NET type: string. This a simple field for adding information that the Connector can provide, and that the qoute document need to display.

Declaration
public virtual string ExtraField1 { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[1024].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ExtraField2

.NET type: string. This a simple field for adding information that the Connector can provide, and that the qoute document need to display.

Declaration
public virtual string ExtraField2 { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[1024].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ExtraField3

.NET type: string. This a simple field for adding information that the Connector can provide, and that the qoute document need to display.

Declaration
public virtual string ExtraField3 { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[1024].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ExtraField4

.NET type: string. This a simple field for adding information that the Connector can provide, and that the qoute document need to display.

Declaration
public virtual string ExtraField4 { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[1024].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ExtraField5

.NET type: string. This a simple field for adding information that the Connector can provide, and that the qoute document need to display.

Declaration
public virtual string ExtraField5 { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[1024].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ExtraInfo

.NET type: string. Extra data (fields with labels). Shall be shown in the quoteline dialog. Additional info that the ERP system would like to store and show in the user interface. Information placed here is shown in the GUI if the “provide-extra-data” capability is true. Different products can have different fields. It will not be possible to directly put info here into the quote document.

Declaration
public virtual string ExtraInfo { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: Clob.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

InAssortment

.NET type: short. True for products that should currently be offered, false when the product is discontinued and should not ordinarily be offered. When false the product no longer appears in search results.

Declaration
public virtual short InAssortment { get; set; }
Property Value
Type Description
short
Remarks

Original type in dictionary: Bool.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

InnerFieldValuePairs

The values of all the fields in the row.
The first field is the primary key.
The index of the value corresponds to the name of the field returned from the Fields property.

Declaration
protected override ArgumentParameterCollection InnerFieldValuePairs { get; }
Property Value
Type Description
ArgumentParameterCollection
Overrides
PrivateSave.InnerFieldValuePairs
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

InnerPrimaryKey

The primary key needed to decide which specific row to alter with the current sql-command.

Declaration
protected override FieldInfo InnerPrimaryKey { get; }
Property Value
Type Description
FieldInfo
Overrides
PrivateSave.InnerPrimaryKey
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

InnerPrimaryKeyValue

The actual value the primary key must have.

Declaration
protected override Parameter InnerPrimaryKeyValue { get; }
Property Value
Type Description
Parameter
Overrides
PrivateSave.InnerPrimaryKeyValue
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

IsDirty

Is the row dirty, e.g. been modified since the last time it was saved to the database.

Declaration
public override bool IsDirty { get; }
Property Value
Type Description
bool
Overrides
TableRowBase.IsDirty
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

IsNew

Is this object new, meaning that it does not exist in the database.

Declaration
public override bool IsNew { get; }
Property Value
Type Description
bool
Overrides
TableRowBase.IsNew
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

IsSubscription

.NET type: short. Is this a subscription product, sold in repeating intervals/amounts?

Declaration
public virtual short IsSubscription { get; set; }
Property Value
Type Description
short
Remarks

Original type in dictionary: Bool.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

this[string]

Get or set a value based on the name of the field.

Declaration
public override object this[string fieldName] { get; set; }
Parameters
Type Name Description
string fieldName

Name of the field in the database

Property Value
Type Description
object

Value of the field.

Overrides
TableRowBase.this[string]
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

Exceptions
Type Condition
ArgumentException

Thrown if the field is not known.

ItemNumber

.NET type: string. Line item number, NOR: «Postnummer». Specific numbers from some hierarchy, for instance “1.4.3.2P”. Typically used to sort the items in the quote by some standard way.

Declaration
public virtual string ItemNumber { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[80].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Name

.NET type: string. The name to use in the user interface.

Declaration
public virtual string Name { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

PriceListId

.NET type: int. Foreign key to the price list that this product is a part of.

Declaration
public virtual int PriceListId { get; set; }
Property Value
Type Description
int
Remarks

Original type in dictionary: FK.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

PriceUnit

.NET type: string. What is the unit (meter, ton, bushel, microsecond, gradus, τρυβλίον, 五合枡, دونم or whatever); read-only for lines that originate in defined products

Declaration
public virtual string PriceUnit { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[80].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ProductCategoryKey

.NET type: string. Either a List id to an id from a connector provided list, or, if the connection doesn’t support lists, a text with the actual product category.

Declaration
public virtual string ProductCategoryKey { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ProductFamilyKey

.NET type: string. Either a List id to an id from a connector provided list, or, if the connection doesn't support lists, a text with the actual product family.

Declaration
public virtual string ProductFamilyKey { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ProductId

.NET type: int. Primary key

Declaration
public virtual int ProductId { get; }
Property Value
Type Description
int
Remarks

Original type in dictionary: PK.

This field is the primary key and can only be read, never written.

This field is not protected by the Sentry system, and can always be read

ProductTableInfo

Get the ProductTableInfo object associated with the row.

Declaration
public ProductTableInfo ProductTableInfo { get; }
Property Value
Type Description
ProductTableInfo
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

ProductTypeKey

.NET type: string. Either a List id to an id from a connector provided list, or, if the connection doesn’t support lists, a text with the actual product type.

Declaration
public virtual string ProductTypeKey { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

QuantityUnit

.NET type: string. What is the unit (meter, ton, bushel, microsecond, gradus, τρυβλίον, 五合枡, دونم or whatever); Connector handles conversion relative to PriceUnit if they are different

Declaration
public virtual string QuantityUnit { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[80].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Registered

.NET type: DateTime. Registered when in UTC

Declaration
public virtual DateTime Registered { get; set; }
Property Value
Type Description
DateTime
Remarks

Original type in dictionary: UtcDateTime.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

RegisteredAssociateId

.NET type: int. Registered by whom

Declaration
public virtual int RegisteredAssociateId { get; set; }
Property Value
Type Description
int
Remarks

Original type in dictionary: FK.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Rights

.NET type: string. Field1=right&Field2=right, etc. of any fields that have non-standard field access rights. Rights can be one of: N (=None or Hidden), R (=Read-only), W (=Writeable), M (=Mandatory). The fields will mostly be from the Quoteline table, but some added fields that are conceptually part of the quoteline, like Image will also be possibly to set rights on. Will be used by SuperOffice to control the user interface when showing the record.

Declaration
public virtual string Rights { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[2048].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Rule

.NET type: string. The names of one or more calculation rules that are in effect for this line, comma-separated case-insensitive. Will NOT be used by SuperOffice.

Declaration
public virtual string Rule { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

SubscriptionUnit

.NET type: string. Either a List id to an id from a connector provided list, or, if the connection doesn’t support lists, a text with the actual subscription unit.

Declaration
public virtual string SubscriptionUnit { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Supplier

.NET type: string. In SuperOffice, an id from the contact table, when saved as an ERP cache, the name of the supplier

Declaration
public virtual string Supplier { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

SupplierCode

.NET type: string. Suppliers part code/number or other key-like field

Declaration
public virtual string SupplierCode { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

TableInfo

Get the TableInfo for the table.

Declaration
public override TableInfo TableInfo { get; }
Property Value
Type Description
TableInfo

The TableInfo for the table.

Overrides
TableRowBase.TableInfo
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

UnitCost

.NET type: double. The cost price. Might not be given, use Decimal.MinValue to signal this.

Declaration
public virtual double UnitCost { get; set; }
Property Value
Type Description
double
Remarks

Original type in dictionary: Double.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

UnitListPrice

.NET type: double. (Basic Price, normal price, standard price.) This is the basic price from which the discount is computed from. The ListPrice will stay the same even when a larger amount is ordered.

Declaration
public virtual double UnitListPrice { get; set; }
Property Value
Type Description
double
Remarks

Original type in dictionary: Double.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

UnitMinimumPrice

.NET type: double. The minimum price this salesman can offer to his customer. This might be cost price if there is no policy. Might not be given, use Decimal.MinValue to signal this.

Declaration
public virtual double UnitMinimumPrice { get; set; }
Property Value
Type Description
double
Remarks

Original type in dictionary: Double.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Updated

.NET type: DateTime. Last updated when in UTC

Declaration
public virtual DateTime Updated { get; set; }
Property Value
Type Description
DateTime
Remarks

Original type in dictionary: UtcDateTime.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

UpdatedAssociateId

.NET type: int. Last updated by whom

Declaration
public virtual int UpdatedAssociateId { get; set; }
Property Value
Type Description
int
Remarks

Original type in dictionary: FK.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

UpdatedCount

.NET type: short. Number of updates made to this record

Declaration
public virtual short UpdatedCount { get; set; }
Property Value
Type Description
short
Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Url

.NET type: string. URL to product information web page.

Declaration
public virtual string Url { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[1024].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

VAT

.NET type: double. Tax/VAT if available from ERP system. THIS IS A PERCENTAGE. In the Superoffice product register, this field is available in the product admin GUI.

Declaration
public virtual double VAT { get; set; }
Property Value
Type Description
double
Remarks

Original type in dictionary: Double.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

VATInfo

.NET type: string. A field for putting VATInfo you need to show in the final quoteDocument, like the VAT type that is used. Not used in any business logic in SuperOffice; available to document templates.

Declaration
public virtual string VATInfo { get; set; }
Property Value
Type Description
string
Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Methods

CreateNew()

Create a new instance of the ProductRow object. One Product, member of one price list

Declaration
public static ProductRow CreateNew()
Returns
Type Description
ProductRow

A new instance of the ProductRow object.

Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

GetFromCustomSearch(CustomSearch)

Create a new instance of the ProductRow object, and populate it with data from a custom search. If the search returns no results, an object with IsNew will be returned; if the result contains one row, an object representing that row will be returned. If the result contains more than one row, the first row will be used and the rest discarded (there is no way of detecting this situation).

Declaration
public static ProductRow GetFromCustomSearch(ProductRow.CustomSearch query)
Parameters
Type Name Description
ProductRow.CustomSearch query

The custom search to execute against the database

Returns
Type Description
ProductRow

A new instance of the ProductRow object, reflecting the result of the query.

Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

GetFromCustomSearchAsync(CustomSearch, CancellationToken)

Create a new instance of the ProductRow object, and populate it with data from a custom search. If the search returns no results, an object with IsNew will be returned; if the result contains one row, an object representing that row will be returned. If the result contains more than one row, the first row will be used and the rest discarded (there is no way of detecting this situation).

Declaration
[CreateSyncVersion(OmitNullableDirective = true)]
public static Task<ProductRow> GetFromCustomSearchAsync(ProductRow.CustomSearch query, CancellationToken cancellationToken = default)
Parameters
Type Name Description
ProductRow.CustomSearch query

The custom search to execute against the database

CancellationToken cancellationToken
Returns
Type Description
Task<ProductRow>

A new instance of the ProductRow object, reflecting the result of the query.

Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

GetFromIdxProductIdAsync(int, CancellationToken)

Create a new instance of the ProductRow object, by querying the database table via the index 'IDXProductId'. This method is intended to make it easy to use efficient queries that match a database index.

Declaration
public static Task<ProductRow> GetFromIdxProductIdAsync(int productId, CancellationToken cancellationToken = default)
Parameters
Type Name Description
int productId
CancellationToken cancellationToken
Returns
Type Description
Task<ProductRow>

Row object that represents the result of the search. IsNew will be true if the query did not match any row in the table

Remarks

This method represents one of the unique indexes on the Product table. Non-unique indexes have corresponding inner classes and methods in the ProductRows collection, since they may return more than one row.

GetFromReader(SoDataReader, ProductTableInfo)

Create a new instance of the ProductRow object, and populate it with data from a reader/tableinfo. If the reader has DBNull as the current value of the primary key field, an unpopulated object with IsNew == true will be returned. If any fields are missing or one of the non-primary key fields is DBNull, an exception will be thrown. One Product, member of one price list

Declaration
public static ProductRow GetFromReader(SoDataReader reader, ProductTableInfo tableInfo)
Parameters
Type Name Description
SoDataReader reader

SoDataReader positioned to a valid database row.

ProductTableInfo tableInfo

ProductTableInfo instance used in the query that is the source of the reader. The fields used from the reader will be those owned by this tableinfo object.

Returns
Type Description
ProductRow

A new instance of the ProductRow object.

Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

GetPersistedFieldValue(FieldInfo)

Get the persisted value of a field.

Declaration
public override object GetPersistedFieldValue(FieldInfo field)
Parameters
Type Name Description
FieldInfo field

Specification of a field

Returns
Type Description
object

Field value, such as an int, DateTime, string ... Null can be returned if the value is not known.

Overrides
PrivateSave.GetPersistedFieldValue(FieldInfo)
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

Exceptions
Type Condition
ArgumentException

Thrown if the field is not known.

InternalSetValue(string, object)

One Product, member of one price list
Row Object for table 'Product'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Declaration
protected override void InternalSetValue(string fieldName, object value)
Parameters
Type Name Description
string fieldName
object value
Overrides
TableRowBase.InternalSetValue(string, object)
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

IsPersistedFieldValueKnown(FieldInfo)

Check if the persisted value for a field is known.

Declaration
public override bool IsPersistedFieldValueKnown(FieldInfo field)
Parameters
Type Name Description
FieldInfo field

Specification of a field

Returns
Type Description
bool

True if the value is known and sentry permits read.

Overrides
PrivateSave.IsPersistedFieldValueKnown(FieldInfo)
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

OnLoad(SoDataReader, TableInfo)

Fill the object with data returned from the database.

Declaration
protected override void OnLoad(SoDataReader reader, TableInfo tableInfo)
Parameters
Type Name Description
SoDataReader reader

Object holding the data returned from the database.

TableInfo tableInfo

The TableInfo used for the SELECT statement.

Overrides
TableRowBase.OnLoad(SoDataReader, TableInfo)
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

OnSaveAsync(BatchSave)

Add the object to the BatchSave list if it needs saving.

Declaration
protected override Task OnSaveAsync(BatchSave batchSave)
Parameters
Type Name Description
BatchSave batchSave

Collection of objects to be saved within the transaction.

Returns
Type Description
Task
Overrides
TableRowBase.OnSaveAsync(BatchSave)
Remarks

Classes overriding this method should call it.

OnSavedAsync(bool)

Method called after the save operation has been performed.

Declaration
protected override Task OnSavedAsync(bool bSucceeded)
Parameters
Type Name Description
bool bSucceeded

True if the save operation succeeded (e.g. transaction committed), or false if the save operation failed (e.g. transaction rolled back)

Returns
Type Description
Task
Overrides
TableRowBase.OnSavedAsync(bool)
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

Reset()

Reset the changes made on the object.

Declaration
protected override void Reset()
Overrides
TableRowBase.Reset()
Remarks

If the row is not persisted to the database (e.g. IsNew is true), all the values will be reset. If the row has been persisted to or loaded from the database, the properties will be set to those of the last persisted or loaded values.

SetDefaultsAsync(DefaulterStrategy, CancellationToken)

Set default values for the row.

Declaration
public override Task SetDefaultsAsync(DefaulterStrategy strategy, CancellationToken cancellationToken = default)
Parameters
Type Name Description
DefaulterStrategy strategy

Strategy used when applying default values; values depend on where we are in the Create/Fetch/Populate/Save cycle

CancellationToken cancellationToken
Returns
Type Description
Task
Overrides
TableRowBase.SetDefaultsAsync(DefaulterStrategy, CancellationToken)
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

SetPrimaryKey(int)

Set the primary key for the row.

Declaration
protected override void SetPrimaryKey(int primaryKey)
Parameters
Type Name Description
int primaryKey

The new primary key for the row.

Overrides
TableRowBase.SetPrimaryKey(int)
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

SetRowAsNew()

One Product, member of one price list
Row Object for table 'Product'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Declaration
public override void SetRowAsNew()
Overrides
TableRowBase.SetRowAsNew()
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

ToString()

ToString method intended for debugging, returns a string that displays the object type, new/dirty status, primary key and the string fields

Declaration
public override string ToString()
Returns
Type Description
string
Overrides
object.ToString()
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

Validate(RowValidator)

Validate this row.

Declaration
public override void Validate(RowValidator rowValidator)
Parameters
Type Name Description
RowValidator rowValidator

RowValidator for inserting the result of the validation

Overrides
TableRowBase.Validate(RowValidator)
Remarks

Row objects can be created in several ways.

  • Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
  • You can create a (nested) ProductRow ProductRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
  • For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.ProductRow.IsNew and SuperOffice.CRM.Data.ProductRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
  • Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the ProductTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, ProductTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.
Non-unique indexes are handled through the ProductRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.ProductRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table Product are:
Index fieldsNested index class name

Implements

INestedPersist
ISoDataLookup
ISentryIgnorable

Extension Methods

EnumUtil.MapEnums<From, To>(From)
ProductRecordDataExtensions.ToRecordData(ProductRow)
Converters.MapEnums<From, To>(From)
QueryExectionExtensions.ExecuteNonQuery(SqlCommand)
QueryExectionExtensions.ExecuteNonQueryAsync(SqlCommand, CancellationToken)
QueryExectionExtensions.ExecuteReader(SqlCommand, bool)
QueryExectionExtensions.ExecuteReaderAsync(SqlCommand, bool, CancellationToken)
QueryExectionExtensions.ExecuteScalarAsync<T>(SqlCommand, bool, CancellationToken)
QueryExectionExtensions.ExecuteScalarAsync<T>(SqlCommand, CancellationToken)
QueryExectionExtensions.ExecuteScalar<T>(SqlCommand)
© SuperOffice. All rights reserved.
SuperOffice |  Community |  Release Notes |  Privacy |  Site feedback |  Search Docs |  About Docs |  Contribute |  Back to top