Class AppointmentRow
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. Row objects correspond directly to database tables, and one
instance of a row object represents one row in the corresponding table in the database.
Inherited Members
Namespace: SuperOffice.CRM.Rows
Assembly: SoDataBase.dll
Syntax
public class AppointmentRow : TableRowBase, INestedPersist, ISoDataLookup, ISentryIgnorable, ISoItem
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
Constructors
AppointmentRow(AppointmentRow.AppointmentRowIdxBase)
Constructor for the class taking an index as argument. Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Declaration
protected AppointmentRow(AppointmentRow.AppointmentRowIdxBase idx)
Parameters
Type | Name | Description |
---|---|---|
AppointmentRow.AppointmentRowIdxBase | 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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
Fields
_currentActiveDate
Current value, see property ActiveDate.
Declaration
protected DateTime _currentActiveDate
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentActiveLinks
Current value, see property ActiveLinks.
Declaration
protected uint _currentActiveLinks
Field Value
Type | Description |
---|---|
UInt32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentAgendaTextId
Current value, see property AgendaTextId.
Declaration
protected int _currentAgendaTextId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentAlarm
Current value, see property Alarm.
Declaration
protected short _currentAlarm
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentAlldayEvent
Current value, see property AlldayEvent.
Declaration
protected AllDayEvent _currentAlldayEvent
Field Value
Type | Description |
---|---|
AllDayEvent |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentAppointmentId
Current value, see property AppointmentId.
Declaration
protected int _currentAppointmentId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentAssignedBy
Current value, see property AssignedBy.
Declaration
protected int _currentAssignedBy
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentAssociateId
Current value, see property AssociateId.
Declaration
protected int _currentAssociateId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentCautionWarning
Current value, see property CautionWarning.
Declaration
protected AppointmentCautionWarning _currentCautionWarning
Field Value
Type | Description |
---|---|
AppointmentCautionWarning |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentCentralserviceVideomeetId
Current value, see property CentralserviceVideomeetId.
Declaration
protected string _currentCentralserviceVideomeetId
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentColorIndex
Current value, see property ColorIndex.
Declaration
protected short _currentColorIndex
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentContactId
Current value, see property ContactId.
Declaration
protected int _currentContactId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentCreatedByWorkflowId
Current value, see property CreatedByWorkflowId.
Declaration
protected int _currentCreatedByWorkflowId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentDoBy
Current value, see property DoBy.
Declaration
protected DateTime _currentDoBy
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentDocumentId
Current value, see property DocumentId.
Declaration
protected int _currentDocumentId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentDone
Current value, see property Done.
Declaration
protected DateTime _currentDone
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentEmailId
Current value, see property EmailId.
Declaration
protected int _currentEmailId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentEndDate
Current value, see property EndDate.
Declaration
protected DateTime _currentEndDate
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentFreeBusy
Current value, see property FreeBusy.
Declaration
protected FreeBusy _currentFreeBusy
Field Value
Type | Description |
---|---|
FreeBusy |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentGroupIdx
Current value, see property GroupIdx.
Declaration
protected int _currentGroupIdx
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentHasAlarm
Current value, see property HasAlarm.
Declaration
protected short _currentHasAlarm
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentInternalNotesTextId
Current value, see property InternalNotesTextId.
Declaration
protected int _currentInternalNotesTextId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentInvitedPersonId
Current value, see property InvitedPersonId.
Declaration
protected int _currentInvitedPersonId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentIsMilestone
Current value, see property IsMilestone.
Declaration
protected short _currentIsMilestone
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentJoinVideomeetUrl
Current value, see property JoinVideomeetUrl.
Declaration
protected string _currentJoinVideomeetUrl
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentLagTime
Current value, see property LagTime.
Declaration
protected short _currentLagTime
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentLeadtime
Current value, see property Leadtime.
Declaration
protected short _currentLeadtime
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentLocation
Current value, see property Location.
Declaration
protected string _currentLocation
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentModifiedAppointmentFields
Current value, see property ModifiedAppointmentFields.
Declaration
protected ModifiedAppointmentFields _currentModifiedAppointmentFields
Field Value
Type | Description |
---|---|
ModifiedAppointmentFields |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentMotherAssociateId
Current value, see property MotherAssociateId.
Declaration
protected int _currentMotherAssociateId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentMotherId
Current value, see property MotherId.
Declaration
protected int _currentMotherId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentOriginalStartDate
Current value, see property OriginalStartDate.
Declaration
protected DateTime _currentOriginalStartDate
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentOwnedExternally
Current value, see property OwnedExternally.
Declaration
protected AppointmentExternalOwner _currentOwnedExternally
Field Value
Type | Description |
---|---|
AppointmentExternalOwner |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentPersonId
Current value, see property PersonId.
Declaration
protected int _currentPersonId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentPreferredTZLocation
Current value, see property PreferredTZLocation.
Declaration
protected int _currentPreferredTZLocation
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentPriorityIdx
Current value, see property PriorityIdx.
Declaration
protected int _currentPriorityIdx
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentPrivate
Current value, see property Private.
Declaration
protected AppointmentPrivate _currentPrivate
Field Value
Type | Description |
---|---|
AppointmentPrivate |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentProjectId
Current value, see property ProjectId.
Declaration
protected int _currentProjectId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentRecurrenceRuleId
Current value, see property RecurrenceRuleId.
Declaration
protected int _currentRecurrenceRuleId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentRegisteredAssociateId
Current value, see property RegisteredAssociateId.
Declaration
protected int _currentRegisteredAssociateId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentRejectCounter
Current value, see property RejectCounter.
Declaration
protected short _currentRejectCounter
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentRejectReason
Current value, see property RejectReason.
Declaration
protected string _currentRejectReason
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentSaleId
Current value, see property SaleId.
Declaration
protected int _currentSaleId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentSendEmail
Current value, see property SendEmail.
Declaration
protected short _currentSendEmail
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentSource
Current value, see property Source.
Declaration
protected short _currentSource
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentStatus
Current value, see property Status.
Declaration
protected AppointmentStatus _currentStatus
Field Value
Type | Description |
---|---|
AppointmentStatus |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentSuggestedAppointmentId
Current value, see property SuggestedAppointmentId.
Declaration
protected int _currentSuggestedAppointmentId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentSuggestedDocumentId
Current value, see property SuggestedDocumentId.
Declaration
protected int _currentSuggestedDocumentId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentTaskIdx
Current value, see property TaskIdx.
Declaration
protected int _currentTaskIdx
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentTextId
Current value, see property TextId.
Declaration
protected int _currentTextId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentType
Current value, see property Type.
Declaration
protected AppointmentType _currentType
Field Value
Type | Description |
---|---|
AppointmentType |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentUpdatedAssociateId
Current value, see property UpdatedAssociateId.
Declaration
protected int _currentUpdatedAssociateId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentUpdatedCount
Current value, see property UpdatedCount.
Declaration
protected short _currentUpdatedCount
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentUserdef2Id
Current value, see property Userdef2Id.
Declaration
protected int _currentUserdef2Id
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_currentUserdefId
Current value, see property UserdefId.
Declaration
protected int _currentUserdefId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedActiveDate
Persisted value, see property ActiveDate.
Declaration
protected DateTime _persistedActiveDate
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedActiveLinks
Persisted value, see property ActiveLinks.
Declaration
protected uint _persistedActiveLinks
Field Value
Type | Description |
---|---|
UInt32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedAgendaTextId
Persisted value, see property AgendaTextId.
Declaration
protected int _persistedAgendaTextId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedAlarm
Persisted value, see property Alarm.
Declaration
protected short _persistedAlarm
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedAlldayEvent
Persisted value, see property AlldayEvent.
Declaration
protected AllDayEvent _persistedAlldayEvent
Field Value
Type | Description |
---|---|
AllDayEvent |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedAppointmentId
Persisted value, see property AppointmentId.
Declaration
protected int _persistedAppointmentId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedAssignedBy
Persisted value, see property AssignedBy.
Declaration
protected int _persistedAssignedBy
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedAssociateId
Persisted value, see property AssociateId.
Declaration
protected int _persistedAssociateId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedCautionWarning
Persisted value, see property CautionWarning.
Declaration
protected AppointmentCautionWarning _persistedCautionWarning
Field Value
Type | Description |
---|---|
AppointmentCautionWarning |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedCentralserviceVideomeetId
Persisted value, see property CentralserviceVideomeetId.
Declaration
protected string _persistedCentralserviceVideomeetId
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedColorIndex
Persisted value, see property ColorIndex.
Declaration
protected short _persistedColorIndex
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedContactId
Persisted value, see property ContactId.
Declaration
protected int _persistedContactId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedCreatedByWorkflowId
Persisted value, see property CreatedByWorkflowId.
Declaration
protected int _persistedCreatedByWorkflowId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedDoBy
Persisted value, see property DoBy.
Declaration
protected DateTime _persistedDoBy
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedDocumentId
Persisted value, see property DocumentId.
Declaration
protected int _persistedDocumentId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedDone
Persisted value, see property Done.
Declaration
protected DateTime _persistedDone
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedEmailId
Persisted value, see property EmailId.
Declaration
protected int _persistedEmailId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedEndDate
Persisted value, see property EndDate.
Declaration
protected DateTime _persistedEndDate
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedFreeBusy
Persisted value, see property FreeBusy.
Declaration
protected FreeBusy _persistedFreeBusy
Field Value
Type | Description |
---|---|
FreeBusy |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedGroupIdx
Persisted value, see property GroupIdx.
Declaration
protected int _persistedGroupIdx
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedHasAlarm
Persisted value, see property HasAlarm.
Declaration
protected short _persistedHasAlarm
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedInternalNotesTextId
Persisted value, see property InternalNotesTextId.
Declaration
protected int _persistedInternalNotesTextId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedInvitedPersonId
Persisted value, see property InvitedPersonId.
Declaration
protected int _persistedInvitedPersonId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedIsMilestone
Persisted value, see property IsMilestone.
Declaration
protected short _persistedIsMilestone
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedJoinVideomeetUrl
Persisted value, see property JoinVideomeetUrl.
Declaration
protected string _persistedJoinVideomeetUrl
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedLagTime
Persisted value, see property LagTime.
Declaration
protected short _persistedLagTime
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedLeadtime
Persisted value, see property Leadtime.
Declaration
protected short _persistedLeadtime
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedLocation
Persisted value, see property Location.
Declaration
protected string _persistedLocation
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedModifiedAppointmentFields
Persisted value, see property ModifiedAppointmentFields.
Declaration
protected ModifiedAppointmentFields _persistedModifiedAppointmentFields
Field Value
Type | Description |
---|---|
ModifiedAppointmentFields |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedMotherAssociateId
Persisted value, see property MotherAssociateId.
Declaration
protected int _persistedMotherAssociateId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedMotherId
Persisted value, see property MotherId.
Declaration
protected int _persistedMotherId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedOriginalStartDate
Persisted value, see property OriginalStartDate.
Declaration
protected DateTime _persistedOriginalStartDate
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedOwnedExternally
Persisted value, see property OwnedExternally.
Declaration
protected AppointmentExternalOwner _persistedOwnedExternally
Field Value
Type | Description |
---|---|
AppointmentExternalOwner |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedPersonId
Persisted value, see property PersonId.
Declaration
protected int _persistedPersonId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedPreferredTZLocation
Persisted value, see property PreferredTZLocation.
Declaration
protected int _persistedPreferredTZLocation
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedPriorityIdx
Persisted value, see property PriorityIdx.
Declaration
protected int _persistedPriorityIdx
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedPrivate
Persisted value, see property Private.
Declaration
protected AppointmentPrivate _persistedPrivate
Field Value
Type | Description |
---|---|
AppointmentPrivate |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedProjectId
Persisted value, see property ProjectId.
Declaration
protected int _persistedProjectId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedRecurrenceRuleId
Persisted value, see property RecurrenceRuleId.
Declaration
protected int _persistedRecurrenceRuleId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedRegisteredAssociateId
Persisted value, see property RegisteredAssociateId.
Declaration
protected int _persistedRegisteredAssociateId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedRejectCounter
Persisted value, see property RejectCounter.
Declaration
protected short _persistedRejectCounter
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedRejectReason
Persisted value, see property RejectReason.
Declaration
protected string _persistedRejectReason
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedSaleId
Persisted value, see property SaleId.
Declaration
protected int _persistedSaleId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedSendEmail
Persisted value, see property SendEmail.
Declaration
protected short _persistedSendEmail
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedSource
Persisted value, see property Source.
Declaration
protected short _persistedSource
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedStatus
Persisted value, see property Status.
Declaration
protected AppointmentStatus _persistedStatus
Field Value
Type | Description |
---|---|
AppointmentStatus |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedSuggestedAppointmentId
Persisted value, see property SuggestedAppointmentId.
Declaration
protected int _persistedSuggestedAppointmentId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedSuggestedDocumentId
Persisted value, see property SuggestedDocumentId.
Declaration
protected int _persistedSuggestedDocumentId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedTaskIdx
Persisted value, see property TaskIdx.
Declaration
protected int _persistedTaskIdx
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedTextId
Persisted value, see property TextId.
Declaration
protected int _persistedTextId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedType
Persisted value, see property Type.
Declaration
protected AppointmentType _persistedType
Field Value
Type | Description |
---|---|
AppointmentType |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedUpdatedAssociateId
Persisted value, see property UpdatedAssociateId.
Declaration
protected int _persistedUpdatedAssociateId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedUpdatedCount
Persisted value, see property UpdatedCount.
Declaration
protected short _persistedUpdatedCount
Field Value
Type | Description |
---|---|
Int16 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedUserdef2Id
Persisted value, see property Userdef2Id.
Declaration
protected int _persistedUserdef2Id
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_persistedUserdefId
Persisted value, see property UserdefId.
Declaration
protected int _persistedUserdefId
Field Value
Type | Description |
---|---|
Int32 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
Properties
ActiveDate
.NET type: DateTime. The date to be used for searching & showing
Declaration
public virtual DateTime ActiveDate { get; set; }
Property Value
Type | Description |
---|---|
DateTime |
Remarks
Original type in dictionary: DateTime.
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
ActiveLinks
.NET type: uint. Number of active links to documents, other appointments, and such
Declaration
public virtual uint ActiveLinks { get; set; }
Property Value
Type | Description |
---|---|
UInt32 |
Remarks
Original type in dictionary: UInt.
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
AgendaTextId
.NET type: int. ID of record containing agenda text
Declaration
public virtual int AgendaTextId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
Alarm
.NET type: short. Alarm leadtime, the alarm flag has moved to hasAlarm
Declaration
public virtual short Alarm { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
Remarks
Original type in dictionary: UShort.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
AlldayEvent
.NET type: AllDayEvent. Is this an all day event: 0 = No, 1 = Yes
Declaration
public virtual AllDayEvent AlldayEvent { get; set; }
Property Value
Type | Description |
---|---|
AllDayEvent |
Remarks
Original type in dictionary: Enum.
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
AppointmentId
.NET type: int. Primary key
Declaration
public virtual int AppointmentId { get; }
Property Value
Type | Description |
---|---|
Int32 |
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
AppointmentTableInfo
Get the AppointmentTableInfo object associated with the row.
Declaration
public AppointmentTableInfo AppointmentTableInfo { get; }
Property Value
Type | Description |
---|---|
AppointmentTableInfo |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
AssignedBy
.NET type: int. Who (last) assigned this appointment to associate_id?
Declaration
public virtual int AssignedBy { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
AssociateId
.NET type: int. ID of associate whose diary the appointment is in, REQUIRED
Declaration
public virtual int AssociateId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
Setting this field to a new value will reset the Sentry and recalculate your rights based on the new value
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
CautionWarning
.NET type: AppointmentCautionWarning. Status field to indicate appointments that have some sort of problem
Declaration
public virtual AppointmentCautionWarning CautionWarning { get; set; }
Property Value
Type | Description |
---|---|
AppointmentCautionWarning |
Remarks
Original type in dictionary: Enum.
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
CentralserviceVideomeetId
.NET type: string. GUID for video meeting in central services – this is set when we create meetings from SuperOffice. It is blank for incoming meetings created from inbox.
Declaration
public virtual string CentralserviceVideomeetId { get; set; }
Property Value
Type | Description |
---|---|
String |
Remarks
Original type in dictionary: String[101].
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
ColorIndex
.NET type: short. Appointment colour, used only in Japanese versions. Western versions take colour from Task
Declaration
public virtual short ColorIndex { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
Remarks
Original type in dictionary: UShort.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
ContactId
.NET type: int. Contact ID of owning contact, may be 0
Declaration
public virtual int ContactId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
CreatedByWorkflowId
.NET type: int. The workflow this follow-up was created by
Declaration
public virtual int CreatedByWorkflowId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
DoBy
.NET type: DateTime. date + start time planned
Declaration
public virtual DateTime DoBy { get; set; }
Property Value
Type | Description |
---|---|
DateTime |
Remarks
Original type in dictionary: DateTime.
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
DocumentId
.NET type: int. Points to document record; 0 for non-document appointments!
Declaration
public virtual int DocumentId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Done
.NET type: DateTime. date + start time this task was done
Declaration
public virtual DateTime Done { get; set; }
Property Value
Type | Description |
---|---|
DateTime |
Remarks
Original type in dictionary: DateTime.
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
EmailId
.NET type: int. If invitation and status changes should be mailed, this is the ID of the email address used
Declaration
public virtual int EmailId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
EndDate
.NET type: DateTime. Date + end time planned
Declaration
public virtual DateTime EndDate { get; set; }
Property Value
Type | Description |
---|---|
DateTime |
Remarks
Original type in dictionary: DateTime.
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
FreeBusy
.NET type: FreeBusy. What kind of time is this: 0 = Busy, 1 = Free
Declaration
public virtual FreeBusy FreeBusy { get; set; }
Property Value
Type | Description |
---|---|
FreeBusy |
Remarks
Original type in dictionary: Enum.
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
GroupIdx
.NET type: int. Group of owning associate at the time tha ppnt was created
Declaration
public virtual int GroupIdx { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
Setting this field to a new value will reset the Sentry and recalculate your rights based on the new value
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
HasAlarm
.NET type: short. Does this appointment have an alarm
Declaration
public virtual short HasAlarm { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
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
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
InnerPrimaryKeyValue
The actual value the primary key must have.
Declaration
protected override Parameter InnerPrimaryKeyValue { get; }
Property Value
Type | Description |
---|---|
Parameter |
Overrides
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
InternalNotesTextId
.NET type: int. ID of record containing internal notes text
Declaration
public virtual int InternalNotesTextId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
InvitedPersonId
.NET type: int. Valid when mother_id != 0 && mother_id != id
Declaration
public virtual int InvitedPersonId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
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 |
---|---|
Boolean |
Overrides
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
IsMilestone
.NET type: short. Is this appointment a milestone?
Declaration
public virtual short IsMilestone { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
Remarks
Original type in dictionary: Bool.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
IsNew
Is this object new, meaning that it does not exist in the database.
Declaration
public override bool IsNew { get; }
Property Value
Type | Description |
---|---|
Boolean |
Overrides
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
Item[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
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
Exceptions
Type | Condition |
---|---|
ArgumentException | Thrown if the field is not known. |
JoinVideomeetUrl
.NET type: string. Blank when not a video meeting. Filled with Join Meeting URL when created.
Declaration
public virtual string JoinVideomeetUrl { get; set; }
Property Value
Type | Description |
---|---|
String |
Remarks
Original type in dictionary: String[2001].
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
LagTime
.NET type: short. as leadtime, but after the end - time blocked for travel etc.
Declaration
public virtual short LagTime { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
Remarks
Original type in dictionary: UShort.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Leadtime
.NET type: short. Time blocked (minutes) BEFORE starttime
Declaration
public virtual short Leadtime { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
Remarks
Original type in dictionary: UShort.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Location
.NET type: string. Location for appointment, defaulted from invited resource of type place and other rules, but you can write anything you want here
Declaration
public virtual string Location { 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
ModifiedAppointmentFields
.NET type: ModifiedAppointmentFields. Which important fields of an appointment have been changed. Used by notifications.
Declaration
public virtual ModifiedAppointmentFields ModifiedAppointmentFields { get; set; }
Property Value
Type | Description |
---|---|
ModifiedAppointmentFields |
Remarks
Original type in dictionary: Enum.
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
MotherAssociateId
.NET type: int. Associate/owner of the mother appointment
Declaration
public virtual int MotherAssociateId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
MotherId
.NET type: int. ID of mother appointment; self if booking master, master ID if booking slave, 0 if normal appointment. However, if 0 and assoc_id != reg_id then this is an assigned appointment, indicated vt type = kBooking
Declaration
public virtual int MotherId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
OriginalStartDate
.NET type: DateTime. The original start date for an appointment in a recurring series
Declaration
public virtual DateTime OriginalStartDate { get; set; }
Property Value
Type | Description |
---|---|
DateTime |
Remarks
Original type in dictionary: DateTime.
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
OwnedExternally
.NET type: AppointmentExternalOwner. Set if an external system owns this appointment.
Declaration
public virtual AppointmentExternalOwner OwnedExternally { get; set; }
Property Value
Type | Description |
---|---|
AppointmentExternalOwner |
Remarks
Original type in dictionary: Enum.
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
PersonId
.NET type: int. Person ID of person the appointment is with, may be 0
Declaration
public virtual int PersonId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
PreferredTZLocation
.NET type: int. Preferred timezone location to use when displaying/editing this appointment
Declaration
public virtual int PreferredTZLocation { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
PriorityIdx
.NET type: int. Link to priority list
Declaration
public virtual int PriorityIdx { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Private
.NET type: AppointmentPrivate. Obsolete, but still maintained field for appointment privacy; denormalization of visiblefor status
Declaration
public virtual AppointmentPrivate Private { get; set; }
Property Value
Type | Description |
---|---|
AppointmentPrivate |
Remarks
Original type in dictionary: Enum.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((short)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
ProjectId
.NET type: int. ID of project referred to, may be 0
Declaration
public virtual int ProjectId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
RecurrenceRuleId
.NET type: int. Pointer to recurrence rule, for recurring appointments, otherwise 0
Declaration
public virtual int RecurrenceRuleId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
Registered
.NET type: DateTime. Registered date in UTC
Declaration
public virtual DateTime Registered { get; set; }
Property Value
Type | Description |
---|---|
DateTime |
Remarks
Original type in dictionary: UtcDateTime.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (DateTime.MinValue)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
RegisteredAssociateId
.NET type: int. Registered by whom
Declaration
public virtual int RegisteredAssociateId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
RejectCounter
.NET type: short. How many invitees have rejected this appointment
Declaration
public virtual short RejectCounter { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
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
RejectReason
.NET type: string. Why was this booking or assignment rejected, the RejectReason list is a source of suggestions but you can write anything here
Declaration
public virtual string RejectReason { 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
SaleId
.NET type: int. Owning sale, if any (may be 0)
Declaration
public virtual int SaleId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
SendEmail
.NET type: short. Send invitation and appointment changes by e-mail to this participant.
Declaration
public virtual short SendEmail { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
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
Source
.NET type: short. For future integration use; source of record
Declaration
public virtual short Source { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
Remarks
Original type in dictionary: UShort.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Status
.NET type: AppointmentStatus. status=done,started, not started, hidden
Declaration
public virtual AppointmentStatus Status { get; set; }
Property Value
Type | Description |
---|---|
AppointmentStatus |
Remarks
Original type in dictionary: Enum.
Setting this field to a new value will reset the Sentry and recalculate your rights based on the new value
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((short)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
SuggestedAppointmentId
.NET type: int. Suggested guide item that this appointment is an instance of (Note: NOT VALID for document-type appointments, they have their own link)
Declaration
public virtual int SuggestedAppointmentId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
SuggestedDocumentId
.NET type: int. Suggested guide item that this document is an instance of (Note: NOT valid for appointments, they have their own link)
Declaration
public virtual int SuggestedDocumentId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
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
TableInfo
Get the TableInfo for the table.
Declaration
public override TableInfo TableInfo { get; }
Property Value
Type | Description |
---|---|
TableInfo | The TableInfo for the table. |
Overrides
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
TaskIdx
.NET type: int. Link to Task list, OR to DocTmpl list, if this is a document
Declaration
public virtual int TaskIdx { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
TextId
.NET type: int. ID of record containing appointment text
Declaration
public virtual int TextId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Type
.NET type: AppointmentType. where=no start time,note,docin, docout
Declaration
public virtual AppointmentType Type { get; set; }
Property Value
Type | Description |
---|---|
AppointmentType |
Remarks
Original type in dictionary: Enum.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((short)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Updated
.NET type: DateTime. Updated date in UTC
Declaration
public virtual DateTime Updated { get; set; }
Property Value
Type | Description |
---|---|
DateTime |
Remarks
Original type in dictionary: UtcDateTime.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (DateTime.MinValue)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
UpdatedAssociateId
.NET type: int. Updated by who
Declaration
public virtual int UpdatedAssociateId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
UpdatedCount
.NET type: short. Number of updates made to this record
Declaration
public virtual short UpdatedCount { get; set; }
Property Value
Type | Description |
---|---|
Int16 |
Remarks
Original type in dictionary: UShort.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value ((Int16)0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Userdef2Id
.NET type: int. User defined table record 2 (for future use)
Declaration
public virtual int Userdef2Id { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
UserdefId
.NET type: int. User defined table record 1 (for future use)
Declaration
public virtual int UserdefId { get; set; }
Property Value
Type | Description |
---|---|
Int32 |
Remarks
Original type in dictionary: FK.
You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)
You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)
Setting this field to a new value will not affect the Sentry calculations and your rights
Exceptions
Type | Condition |
---|---|
SoSentryException | Thrown if the set method is accessed without having the Write access right to the field |
Methods
add__onActiveDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onActiveDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onActiveLinksChange(OnFieldChange<UInt32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onActiveLinksChange(OnFieldChange<uint> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<UInt32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onAgendaTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onAgendaTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onAlarmChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onAlarmChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onAlldayEventChange(OnFieldChange<AllDayEvent>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onAlldayEventChange(OnFieldChange<AllDayEvent> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AllDayEvent> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onAssignedByChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onAssignedByChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onCautionWarningChange(OnFieldChange<AppointmentCautionWarning>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onCautionWarningChange(OnFieldChange<AppointmentCautionWarning> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentCautionWarning> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onCentralserviceVideomeetIdChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onCentralserviceVideomeetIdChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onColorIndexChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onColorIndexChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onContactIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onContactIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onCreatedByWorkflowIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onCreatedByWorkflowIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onDoByChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onDoByChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onDocumentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onDocumentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onDoneChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onDoneChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onEmailIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onEmailIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onEndDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onEndDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onFreeBusyChange(OnFieldChange<FreeBusy>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onFreeBusyChange(OnFieldChange<FreeBusy> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<FreeBusy> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onGroupIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onGroupIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onHasAlarmChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onHasAlarmChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onInternalNotesTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onInternalNotesTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onInvitedPersonIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onInvitedPersonIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onIsMilestoneChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onIsMilestoneChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onJoinVideomeetUrlChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onJoinVideomeetUrlChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onLagTimeChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onLagTimeChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onLeadtimeChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onLeadtimeChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onLocationChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onLocationChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onModifiedAppointmentFieldsChange(OnFieldChange<ModifiedAppointmentFields>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onModifiedAppointmentFieldsChange(OnFieldChange<ModifiedAppointmentFields> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<ModifiedAppointmentFields> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onMotherAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onMotherAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onMotherIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onMotherIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onOriginalStartDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onOriginalStartDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onOwnedExternallyChange(OnFieldChange<AppointmentExternalOwner>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onOwnedExternallyChange(OnFieldChange<AppointmentExternalOwner> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentExternalOwner> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onPersonIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onPersonIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onPreferredTZLocationChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onPreferredTZLocationChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onPriorityIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onPriorityIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onPrivateChange(OnFieldChange<AppointmentPrivate>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onPrivateChange(OnFieldChange<AppointmentPrivate> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentPrivate> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onProjectIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onProjectIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onRecurrenceRuleIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onRecurrenceRuleIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onRegisteredAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onRegisteredAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onRegisteredChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onRegisteredChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onRejectCounterChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onRejectCounterChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onRejectReasonChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onRejectReasonChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onSaleIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onSaleIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onSendEmailChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onSendEmailChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onSourceChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onSourceChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onStatusChange(OnFieldChange<AppointmentStatus>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onStatusChange(OnFieldChange<AppointmentStatus> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentStatus> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onSuggestedAppointmentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onSuggestedAppointmentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onSuggestedDocumentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onSuggestedDocumentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onTaskIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onTaskIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onTypeChange(OnFieldChange<AppointmentType>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onTypeChange(OnFieldChange<AppointmentType> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentType> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onUpdatedAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onUpdatedAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onUpdatedChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onUpdatedChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onUpdatedCountChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onUpdatedCountChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onUserdef2IdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onUserdef2IdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add__onUserdefIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add__onUserdefIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnActiveDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnActiveDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnActiveLinksChange(OnFieldChange<UInt32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnActiveLinksChange(OnFieldChange<uint> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<UInt32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnAgendaTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnAgendaTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnAlarmChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnAlarmChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnAlldayEventChange(OnFieldChange<AllDayEvent>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnAlldayEventChange(OnFieldChange<AllDayEvent> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AllDayEvent> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnAssignedByChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnAssignedByChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnCautionWarningChange(OnFieldChange<AppointmentCautionWarning>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnCautionWarningChange(OnFieldChange<AppointmentCautionWarning> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentCautionWarning> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnCentralserviceVideomeetIdChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnCentralserviceVideomeetIdChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnColorIndexChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnColorIndexChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnContactIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnContactIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnCreatedByWorkflowIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnCreatedByWorkflowIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnDoByChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnDoByChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnDocumentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnDocumentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnDoneChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnDoneChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnEmailIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnEmailIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnEndDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnEndDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnFreeBusyChange(OnFieldChange<FreeBusy>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnFreeBusyChange(OnFieldChange<FreeBusy> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<FreeBusy> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnGroupIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnGroupIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnHasAlarmChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnHasAlarmChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnInternalNotesTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnInternalNotesTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnInvitedPersonIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnInvitedPersonIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnIsMilestoneChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnIsMilestoneChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnJoinVideomeetUrlChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnJoinVideomeetUrlChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnLagTimeChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnLagTimeChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnLeadtimeChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnLeadtimeChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnLocationChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnLocationChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnModifiedAppointmentFieldsChange(OnFieldChange<ModifiedAppointmentFields>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnModifiedAppointmentFieldsChange(OnFieldChange<ModifiedAppointmentFields> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<ModifiedAppointmentFields> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnMotherAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnMotherAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnMotherIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnMotherIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnOriginalStartDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnOriginalStartDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnOwnedExternallyChange(OnFieldChange<AppointmentExternalOwner>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnOwnedExternallyChange(OnFieldChange<AppointmentExternalOwner> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentExternalOwner> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnPersonIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnPersonIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnPreferredTZLocationChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnPreferredTZLocationChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnPriorityIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnPriorityIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnPrivateChange(OnFieldChange<AppointmentPrivate>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnPrivateChange(OnFieldChange<AppointmentPrivate> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentPrivate> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnProjectIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnProjectIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnRecurrenceRuleIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnRecurrenceRuleIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnRegisteredAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnRegisteredAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnRegisteredChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnRegisteredChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnRejectCounterChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnRejectCounterChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnRejectReasonChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnRejectReasonChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnSaleIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnSaleIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnSendEmailChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnSendEmailChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnSourceChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnSourceChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnStatusChange(OnFieldChange<AppointmentStatus>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnStatusChange(OnFieldChange<AppointmentStatus> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentStatus> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnSuggestedAppointmentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnSuggestedAppointmentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnSuggestedDocumentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnSuggestedDocumentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnTaskIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnTaskIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnTypeChange(OnFieldChange<AppointmentType>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnTypeChange(OnFieldChange<AppointmentType> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentType> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnUpdatedAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnUpdatedAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnUpdatedChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnUpdatedChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnUpdatedCountChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnUpdatedCountChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnUserdef2IdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnUserdef2IdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnUserdefIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnUserdefIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
add_OnValueChanged(OnTableValueChange)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void add_OnValueChanged(OnTableValueChange value)
Parameters
Type | Name | Description |
---|---|---|
OnTableValueChange | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
CreateNew()
Create a new instance of the AppointmentRow object. Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Declaration
public static AppointmentRow CreateNew()
Returns
Type | Description |
---|---|
AppointmentRow | A new instance of the AppointmentRow 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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
GetAppointmentStatus(InvitationStatus, AssignmentStatus, ActivityStatus)
Convert status from Service Layer to RDB AppointmentStatus
Declaration
public static AppointmentStatus GetAppointmentStatus(InvitationStatus invitationStatus, AssignmentStatus assignmentStatus, ActivityStatus completedStatus)
Parameters
Type | Name | Description |
---|---|---|
InvitationStatus | invitationStatus | |
AssignmentStatus | assignmentStatus | |
ActivityStatus | completedStatus |
Returns
Type | Description |
---|---|
AppointmentStatus | AppointmentStatus converted from InvitationStatus, AssignmentStatus and CompletedStatus |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
GetAssignmentStatus(AppointmentStatus)
Convert RDB AppointmentStatus to Assignment Status in the Service Layer
Declaration
public static AssignmentStatus GetAssignmentStatus(AppointmentStatus appointmentStatus)
Parameters
Type | Name | Description |
---|---|---|
AppointmentStatus | appointmentStatus | RDB Appointment Status that should be mapped to Assignment status |
Returns
Type | Description |
---|---|
AssignmentStatus | AppointmentStatus converted to AssignmentStatus |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
GetCompletedStatus(AppointmentStatus)
Convert RDB AppointmentStatus to Completed Status in the Service Layer
Declaration
public static ActivityStatus GetCompletedStatus(AppointmentStatus appointmentStatus)
Parameters
Type | Name | Description |
---|---|---|
AppointmentStatus | appointmentStatus | RDB Appointment Status that should be mapped to Completed status |
Returns
Type | Description |
---|---|
ActivityStatus | AppointmentStatus converted to CompletedStatus |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
GetFromCustomSearch(AppointmentRow.CustomSearch)
Create a new instance of the AppointmentRow 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 AppointmentRow GetFromCustomSearch(AppointmentRow.CustomSearch query)
Parameters
Type | Name | Description |
---|---|---|
AppointmentRow.CustomSearch | query | The custom search to execute against the database |
Returns
Type | Description |
---|---|
AppointmentRow | A new instance of the AppointmentRow 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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
GetFromIdxAppointmentId(Int32)
Create a new instance of the AppointmentRow object, by querying the database table via the index 'IDXAppntId'. This method is intended to make it easy to use efficient queries that match a database index.
Declaration
public static AppointmentRow GetFromIdxAppointmentId(int appointmentId)
Parameters
Type | Name | Description |
---|---|---|
Int32 | appointmentId |
Returns
Type | Description |
---|---|
AppointmentRow | 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 Appointment table. Non-unique indexes have corresponding inner classes and methods in the AppointmentRows collection, since they may return more than one row.
GetFromIdxAssociateIdActiveDateMotherIdAppointmentId(Int32, DateTime, Int32, Int32)
Create a new instance of the AppointmentRow object, by querying the database table via the index 'IAssoc_idActiveDateMother_idId'. This method is intended to make it easy to use efficient queries that match a database index.
Declaration
public static AppointmentRow GetFromIdxAssociateIdActiveDateMotherIdAppointmentId(int associateId, DateTime activeDate, int motherId, int appointmentId)
Parameters
Type | Name | Description |
---|---|---|
Int32 | associateId | |
DateTime | activeDate | |
Int32 | motherId | |
Int32 | appointmentId |
Returns
Type | Description |
---|---|
AppointmentRow | 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 Appointment table. Non-unique indexes have corresponding inner classes and methods in the AppointmentRows collection, since they may return more than one row.
GetFromIdxMotherIdStatusActiveDateRegisteredAssociateIdRegisteredAssignedByGroupIdxTypeAssociateIdAppointmentId(Int32, AppointmentStatus, DateTime, Int32, DateTime, Int32, Int32, AppointmentType, Int32, Int32)
Create a new instance of the AppointmentRow object, by querying the database table via the index 'IMother_idStatusActiveDateReg_idRegAssignedByGrp_idxTypeAssoc_idId'. This method is intended to make it easy to use efficient queries that match a database index.
Declaration
public static AppointmentRow GetFromIdxMotherIdStatusActiveDateRegisteredAssociateIdRegisteredAssignedByGroupIdxTypeAssociateIdAppointmentId(int motherId, AppointmentStatus status, DateTime activeDate, int registeredAssociateId, DateTime registered, int assignedBy, int groupIdx, AppointmentType type, int associateId, int appointmentId)
Parameters
Type | Name | Description |
---|---|---|
Int32 | motherId | |
AppointmentStatus | status | |
DateTime | activeDate | |
Int32 | registeredAssociateId | |
DateTime | registered | |
Int32 | assignedBy | |
Int32 | groupIdx | |
AppointmentType | type | |
Int32 | associateId | |
Int32 | appointmentId |
Returns
Type | Description |
---|---|
AppointmentRow | 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 Appointment table. Non-unique indexes have corresponding inner classes and methods in the AppointmentRows collection, since they may return more than one row.
GetFromIdxProjectIdTypeActiveDateDocumentIdAssociateIdGroupIdxMotherIdAssignedByAppointmentIdRegisteredRegisteredAssociateId(Int32, AppointmentType, DateTime, Int32, Int32, Int32, Int32, Int32, Int32, DateTime, Int32)
Create a new instance of the AppointmentRow object, by querying the database table via the index 'IProj_idTypeActiveDateDoc_idAssoc_idGrp_idxMother_idAssignedByIdRegReg_id'. This method is intended to make it easy to use efficient queries that match a database index.
Declaration
public static AppointmentRow GetFromIdxProjectIdTypeActiveDateDocumentIdAssociateIdGroupIdxMotherIdAssignedByAppointmentIdRegisteredRegisteredAssociateId(int projectId, AppointmentType type, DateTime activeDate, int documentId, int associateId, int groupIdx, int motherId, int assignedBy, int appointmentId, DateTime registered, int registeredAssociateId)
Parameters
Type | Name | Description |
---|---|---|
Int32 | projectId | |
AppointmentType | type | |
DateTime | activeDate | |
Int32 | documentId | |
Int32 | associateId | |
Int32 | groupIdx | |
Int32 | motherId | |
Int32 | assignedBy | |
Int32 | appointmentId | |
DateTime | registered | |
Int32 | registeredAssociateId |
Returns
Type | Description |
---|---|
AppointmentRow | 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 Appointment table. Non-unique indexes have corresponding inner classes and methods in the AppointmentRows collection, since they may return more than one row.
GetFromReader(SoDataReader, AppointmentTableInfo)
Create a new instance of the AppointmentRow 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. Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Declaration
public static AppointmentRow GetFromReader(SoDataReader reader, AppointmentTableInfo tableInfo)
Parameters
Type | Name | Description |
---|---|---|
SoDataReader | reader | SoDataReader positioned to a valid database row. |
AppointmentTableInfo | tableInfo | AppointmentTableInfo 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 |
---|---|
AppointmentRow | A new instance of the AppointmentRow 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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
GetInvitationStatus(AppointmentStatus)
Convert RDB AppointmentStatus to Invitation Status in the Service Layer
Declaration
public static InvitationStatus GetInvitationStatus(AppointmentStatus appointmentStatus)
Parameters
Type | Name | Description |
---|---|---|
AppointmentStatus | appointmentStatus | RDB Appointment Status that should be mapped to Invitation status |
Returns
Type | Description |
---|---|
InvitationStatus | AppointmentStatus converted to InvitationStatus |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
Exceptions
Type | Condition |
---|---|
ArgumentException | Thrown if the field is not known. |
InternalSetValue(String, Object)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
IsAppointmentAssignment()
Test if the appointment is an Assignment
Declaration
public bool IsAppointmentAssignment()
Returns
Type | Description |
---|---|
Boolean | Return true if the appointment is an Assignment. |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
IsAppointmentDoByPast()
Check if the appointment is past the do by date
Declaration
public bool IsAppointmentDoByPast()
Returns
Type | Description |
---|---|
Boolean | Return true if DoBy date is older than today's date. |
Remarks
Check if a booking appointments Get Do By date is older than today's date. If it is, return true;
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 |
---|---|
Boolean | True if the value is known and sentry permits read. |
Overrides
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnSave(BatchSave)
Add the object to the BatchSave list if it needs saving.
Declaration
protected override void OnSave(BatchSave batchSave)
Parameters
Type | Name | Description |
---|---|---|
BatchSave | batchSave | Collection of objects to be saved within the transaction. |
Overrides
Remarks
Classes overriding this method should call it.
OnSaved(Boolean)
Method called after the save operation has been performed.
Declaration
protected override void OnSaved(bool bSucceeded)
Parameters
Type | Name | Description |
---|---|---|
Boolean | bSucceeded | True if the save operation succeeded (e.g. transaction committed), or false if the save operation failed (e.g. transaction rolled back) |
Overrides
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onActiveDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onActiveDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onActiveLinksChange(OnFieldChange<UInt32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onActiveLinksChange(OnFieldChange<uint> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<UInt32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onAgendaTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onAgendaTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onAlarmChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onAlarmChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onAlldayEventChange(OnFieldChange<AllDayEvent>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onAlldayEventChange(OnFieldChange<AllDayEvent> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AllDayEvent> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onAssignedByChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onAssignedByChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onCautionWarningChange(OnFieldChange<AppointmentCautionWarning>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onCautionWarningChange(OnFieldChange<AppointmentCautionWarning> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentCautionWarning> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onCentralserviceVideomeetIdChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onCentralserviceVideomeetIdChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onColorIndexChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onColorIndexChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onContactIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onContactIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onCreatedByWorkflowIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onCreatedByWorkflowIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onDoByChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onDoByChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onDocumentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onDocumentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onDoneChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onDoneChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onEmailIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onEmailIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onEndDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onEndDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onFreeBusyChange(OnFieldChange<FreeBusy>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onFreeBusyChange(OnFieldChange<FreeBusy> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<FreeBusy> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onGroupIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onGroupIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onHasAlarmChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onHasAlarmChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onInternalNotesTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onInternalNotesTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onInvitedPersonIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onInvitedPersonIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onIsMilestoneChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onIsMilestoneChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onJoinVideomeetUrlChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onJoinVideomeetUrlChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onLagTimeChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onLagTimeChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onLeadtimeChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onLeadtimeChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onLocationChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onLocationChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onModifiedAppointmentFieldsChange(OnFieldChange<ModifiedAppointmentFields>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onModifiedAppointmentFieldsChange(OnFieldChange<ModifiedAppointmentFields> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<ModifiedAppointmentFields> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onMotherAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onMotherAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onMotherIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onMotherIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onOriginalStartDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onOriginalStartDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onOwnedExternallyChange(OnFieldChange<AppointmentExternalOwner>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onOwnedExternallyChange(OnFieldChange<AppointmentExternalOwner> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentExternalOwner> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onPersonIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onPersonIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onPreferredTZLocationChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onPreferredTZLocationChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onPriorityIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onPriorityIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onPrivateChange(OnFieldChange<AppointmentPrivate>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onPrivateChange(OnFieldChange<AppointmentPrivate> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentPrivate> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onProjectIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onProjectIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onRecurrenceRuleIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onRecurrenceRuleIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onRegisteredAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onRegisteredAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onRegisteredChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onRegisteredChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onRejectCounterChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onRejectCounterChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onRejectReasonChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onRejectReasonChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onSaleIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onSaleIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onSendEmailChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onSendEmailChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onSourceChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onSourceChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onStatusChange(OnFieldChange<AppointmentStatus>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onStatusChange(OnFieldChange<AppointmentStatus> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentStatus> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onSuggestedAppointmentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onSuggestedAppointmentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onSuggestedDocumentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onSuggestedDocumentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onTaskIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onTaskIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onTypeChange(OnFieldChange<AppointmentType>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onTypeChange(OnFieldChange<AppointmentType> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentType> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onUpdatedAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onUpdatedAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onUpdatedChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onUpdatedChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onUpdatedCountChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onUpdatedCountChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onUserdef2IdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onUserdef2IdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove__onUserdefIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove__onUserdefIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnActiveDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnActiveDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnActiveLinksChange(OnFieldChange<UInt32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnActiveLinksChange(OnFieldChange<uint> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<UInt32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnAgendaTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnAgendaTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnAlarmChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnAlarmChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnAlldayEventChange(OnFieldChange<AllDayEvent>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnAlldayEventChange(OnFieldChange<AllDayEvent> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AllDayEvent> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnAssignedByChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnAssignedByChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnCautionWarningChange(OnFieldChange<AppointmentCautionWarning>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnCautionWarningChange(OnFieldChange<AppointmentCautionWarning> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentCautionWarning> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnCentralserviceVideomeetIdChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnCentralserviceVideomeetIdChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnColorIndexChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnColorIndexChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnContactIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnContactIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnCreatedByWorkflowIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnCreatedByWorkflowIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnDoByChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnDoByChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnDocumentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnDocumentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnDoneChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnDoneChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnEmailIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnEmailIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnEndDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnEndDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnFreeBusyChange(OnFieldChange<FreeBusy>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnFreeBusyChange(OnFieldChange<FreeBusy> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<FreeBusy> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnGroupIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnGroupIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnHasAlarmChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnHasAlarmChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnInternalNotesTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnInternalNotesTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnInvitedPersonIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnInvitedPersonIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnIsMilestoneChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnIsMilestoneChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnJoinVideomeetUrlChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnJoinVideomeetUrlChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnLagTimeChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnLagTimeChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnLeadtimeChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnLeadtimeChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnLocationChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnLocationChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnModifiedAppointmentFieldsChange(OnFieldChange<ModifiedAppointmentFields>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnModifiedAppointmentFieldsChange(OnFieldChange<ModifiedAppointmentFields> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<ModifiedAppointmentFields> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnMotherAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnMotherAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnMotherIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnMotherIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnOriginalStartDateChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnOriginalStartDateChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnOwnedExternallyChange(OnFieldChange<AppointmentExternalOwner>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnOwnedExternallyChange(OnFieldChange<AppointmentExternalOwner> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentExternalOwner> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnPersonIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnPersonIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnPreferredTZLocationChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnPreferredTZLocationChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnPriorityIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnPriorityIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnPrivateChange(OnFieldChange<AppointmentPrivate>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnPrivateChange(OnFieldChange<AppointmentPrivate> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentPrivate> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnProjectIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnProjectIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnRecurrenceRuleIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnRecurrenceRuleIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnRegisteredAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnRegisteredAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnRegisteredChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnRegisteredChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnRejectCounterChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnRejectCounterChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnRejectReasonChange(OnFieldChange<String>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnRejectReasonChange(OnFieldChange<string> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<String> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnSaleIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnSaleIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnSendEmailChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnSendEmailChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnSourceChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnSourceChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnStatusChange(OnFieldChange<AppointmentStatus>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnStatusChange(OnFieldChange<AppointmentStatus> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentStatus> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnSuggestedAppointmentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnSuggestedAppointmentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnSuggestedDocumentIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnSuggestedDocumentIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnTaskIdxChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnTaskIdxChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnTextIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnTextIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnTypeChange(OnFieldChange<AppointmentType>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnTypeChange(OnFieldChange<AppointmentType> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<AppointmentType> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnUpdatedAssociateIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnUpdatedAssociateIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnUpdatedChange(OnFieldChange<DateTime>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnUpdatedChange(OnFieldChange<DateTime> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<DateTime> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnUpdatedCountChange(OnFieldChange<Int16>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnUpdatedCountChange(OnFieldChange<short> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int16> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnUserdef2IdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnUserdef2IdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnUserdefIdChange(OnFieldChange<Int32>)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnUserdefIdChange(OnFieldChange<int> value)
Parameters
Type | Name | Description |
---|---|---|
OnFieldChange<Int32> | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
remove_OnValueChanged(OnTableValueChange)
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 void remove_OnValueChanged(OnTableValueChange value)
Parameters
Type | Name | Description |
---|---|---|
OnTableValueChange | value |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
Reset()
Reset the changes made on the object.
Declaration
protected override void Reset()
Overrides
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.
SetDefaults(DefaulterStrategy)
Set default values for the row.
Declaration
public override void SetDefaults(DefaulterStrategy strategy)
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 |
Overrides
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
SetPrimaryKey(Int32)
Set the primary key for the row.
Declaration
protected override void SetPrimaryKey(int primaryKey)
Parameters
Type | Name | Description |
---|---|---|
Int32 | primaryKey | The new primary key for the row. |
Overrides
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
SetRowAsNew()
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
ToggleCompleted()
Toggle the 'completed' status of the appointment.
Declaration
public AppointmentStatus ToggleCompleted()
Returns
Type | Description |
---|---|
AppointmentStatus | New (current, not persisted) value of the status |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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 |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested 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
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
Events
_onActiveDateChange
Change envent for property ActiveDate; field is of .NET type DateTime.
Declaration
protected event OnFieldChange<DateTime> _onActiveDateChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onActiveLinksChange
Change envent for property ActiveLinks; field is of .NET type uint.
Declaration
protected event OnFieldChange<uint> _onActiveLinksChange
Event Type
Type | Description |
---|---|
OnFieldChange<UInt32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onAgendaTextIdChange
Change envent for property AgendaTextId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onAgendaTextIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onAlarmChange
Change envent for property Alarm; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onAlarmChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onAlldayEventChange
Change envent for property AlldayEvent; field is of .NET type short.
Declaration
protected event OnFieldChange<AllDayEvent> _onAlldayEventChange
Event Type
Type | Description |
---|---|
OnFieldChange<AllDayEvent> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onAssignedByChange
Change envent for property AssignedBy; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onAssignedByChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onAssociateIdChange
Change envent for property AssociateId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onAssociateIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onCautionWarningChange
Change envent for property CautionWarning; field is of .NET type short.
Declaration
protected event OnFieldChange<AppointmentCautionWarning> _onCautionWarningChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentCautionWarning> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onCentralserviceVideomeetIdChange
Change envent for property CentralserviceVideomeetId; field is of .NET type string.
Declaration
protected event OnFieldChange<string> _onCentralserviceVideomeetIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onColorIndexChange
Change envent for property ColorIndex; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onColorIndexChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onContactIdChange
Change envent for property ContactId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onContactIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onCreatedByWorkflowIdChange
Change envent for property CreatedByWorkflowId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onCreatedByWorkflowIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onDoByChange
Change envent for property DoBy; field is of .NET type DateTime.
Declaration
protected event OnFieldChange<DateTime> _onDoByChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onDocumentIdChange
Change envent for property DocumentId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onDocumentIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onDoneChange
Change envent for property Done; field is of .NET type DateTime.
Declaration
protected event OnFieldChange<DateTime> _onDoneChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onEmailIdChange
Change envent for property EmailId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onEmailIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onEndDateChange
Change envent for property EndDate; field is of .NET type DateTime.
Declaration
protected event OnFieldChange<DateTime> _onEndDateChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onFreeBusyChange
Change envent for property FreeBusy; field is of .NET type short.
Declaration
protected event OnFieldChange<FreeBusy> _onFreeBusyChange
Event Type
Type | Description |
---|---|
OnFieldChange<FreeBusy> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onGroupIdxChange
Change envent for property GroupIdx; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onGroupIdxChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onHasAlarmChange
Change envent for property HasAlarm; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onHasAlarmChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onInternalNotesTextIdChange
Change envent for property InternalNotesTextId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onInternalNotesTextIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onInvitedPersonIdChange
Change envent for property InvitedPersonId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onInvitedPersonIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onIsMilestoneChange
Change envent for property IsMilestone; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onIsMilestoneChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onJoinVideomeetUrlChange
Change envent for property JoinVideomeetUrl; field is of .NET type string.
Declaration
protected event OnFieldChange<string> _onJoinVideomeetUrlChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onLagTimeChange
Change envent for property LagTime; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onLagTimeChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onLeadtimeChange
Change envent for property Leadtime; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onLeadtimeChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onLocationChange
Change envent for property Location; field is of .NET type string.
Declaration
protected event OnFieldChange<string> _onLocationChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onModifiedAppointmentFieldsChange
Change envent for property ModifiedAppointmentFields; field is of .NET type int.
Declaration
protected event OnFieldChange<ModifiedAppointmentFields> _onModifiedAppointmentFieldsChange
Event Type
Type | Description |
---|---|
OnFieldChange<ModifiedAppointmentFields> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onMotherAssociateIdChange
Change envent for property MotherAssociateId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onMotherAssociateIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onMotherIdChange
Change envent for property MotherId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onMotherIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onOriginalStartDateChange
Change envent for property OriginalStartDate; field is of .NET type DateTime.
Declaration
protected event OnFieldChange<DateTime> _onOriginalStartDateChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onOwnedExternallyChange
Change envent for property OwnedExternally; field is of .NET type short.
Declaration
protected event OnFieldChange<AppointmentExternalOwner> _onOwnedExternallyChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentExternalOwner> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onPersonIdChange
Change envent for property PersonId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onPersonIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onPreferredTZLocationChange
Change envent for property PreferredTZLocation; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onPreferredTZLocationChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onPriorityIdxChange
Change envent for property PriorityIdx; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onPriorityIdxChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onPrivateChange
Change envent for property Private; field is of .NET type short.
Declaration
protected event OnFieldChange<AppointmentPrivate> _onPrivateChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentPrivate> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onProjectIdChange
Change envent for property ProjectId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onProjectIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onRecurrenceRuleIdChange
Change envent for property RecurrenceRuleId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onRecurrenceRuleIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onRegisteredAssociateIdChange
Change envent for property RegisteredAssociateId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onRegisteredAssociateIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onRegisteredChange
Change envent for property Registered; field is of .NET type DateTime.
Declaration
protected event OnFieldChange<DateTime> _onRegisteredChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onRejectCounterChange
Change envent for property RejectCounter; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onRejectCounterChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onRejectReasonChange
Change envent for property RejectReason; field is of .NET type string.
Declaration
protected event OnFieldChange<string> _onRejectReasonChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onSaleIdChange
Change envent for property SaleId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onSaleIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onSendEmailChange
Change envent for property SendEmail; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onSendEmailChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onSourceChange
Change envent for property Source; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onSourceChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onStatusChange
Change envent for property Status; field is of .NET type short.
Declaration
protected event OnFieldChange<AppointmentStatus> _onStatusChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentStatus> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onSuggestedAppointmentIdChange
Change envent for property SuggestedAppointmentId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onSuggestedAppointmentIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onSuggestedDocumentIdChange
Change envent for property SuggestedDocumentId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onSuggestedDocumentIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onTaskIdxChange
Change envent for property TaskIdx; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onTaskIdxChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onTextIdChange
Change envent for property TextId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onTextIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onTypeChange
Change envent for property Type; field is of .NET type short.
Declaration
protected event OnFieldChange<AppointmentType> _onTypeChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentType> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onUpdatedAssociateIdChange
Change envent for property UpdatedAssociateId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onUpdatedAssociateIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onUpdatedChange
Change envent for property Updated; field is of .NET type DateTime.
Declaration
protected event OnFieldChange<DateTime> _onUpdatedChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onUpdatedCountChange
Change envent for property UpdatedCount; field is of .NET type short.
Declaration
protected event OnFieldChange<short> _onUpdatedCountChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onUserdef2IdChange
Change envent for property Userdef2Id; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onUserdef2IdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
_onUserdefIdChange
Change envent for property UserdefId; field is of .NET type int.
Declaration
protected event OnFieldChange<int> _onUserdefIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnActiveDateChange
Event raised when ActiveDate is changing.
Declaration
public event OnFieldChange<DateTime> OnActiveDateChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnActiveLinksChange
Event raised when ActiveLinks is changing.
Declaration
public event OnFieldChange<uint> OnActiveLinksChange
Event Type
Type | Description |
---|---|
OnFieldChange<UInt32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnAgendaTextIdChange
Event raised when AgendaTextId is changing.
Declaration
public event OnFieldChange<int> OnAgendaTextIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnAlarmChange
Event raised when Alarm is changing.
Declaration
public event OnFieldChange<short> OnAlarmChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnAlldayEventChange
Event raised when AlldayEvent is changing.
Declaration
public event OnFieldChange<AllDayEvent> OnAlldayEventChange
Event Type
Type | Description |
---|---|
OnFieldChange<AllDayEvent> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnAssignedByChange
Event raised when AssignedBy is changing.
Declaration
public event OnFieldChange<int> OnAssignedByChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnAssociateIdChange
Event raised when AssociateId is changing.
Declaration
public event OnFieldChange<int> OnAssociateIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnCautionWarningChange
Event raised when CautionWarning is changing.
Declaration
public event OnFieldChange<AppointmentCautionWarning> OnCautionWarningChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentCautionWarning> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnCentralserviceVideomeetIdChange
Event raised when CentralserviceVideomeetId is changing.
Declaration
public event OnFieldChange<string> OnCentralserviceVideomeetIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnColorIndexChange
Event raised when ColorIndex is changing.
Declaration
public event OnFieldChange<short> OnColorIndexChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnContactIdChange
Event raised when ContactId is changing.
Declaration
public event OnFieldChange<int> OnContactIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnCreatedByWorkflowIdChange
Event raised when CreatedByWorkflowId is changing.
Declaration
public event OnFieldChange<int> OnCreatedByWorkflowIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnDoByChange
Event raised when DoBy is changing.
Declaration
public event OnFieldChange<DateTime> OnDoByChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnDocumentIdChange
Event raised when DocumentId is changing.
Declaration
public event OnFieldChange<int> OnDocumentIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnDoneChange
Event raised when Done is changing.
Declaration
public event OnFieldChange<DateTime> OnDoneChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnEmailIdChange
Event raised when EmailId is changing.
Declaration
public event OnFieldChange<int> OnEmailIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnEndDateChange
Event raised when EndDate is changing.
Declaration
public event OnFieldChange<DateTime> OnEndDateChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnFreeBusyChange
Event raised when FreeBusy is changing.
Declaration
public event OnFieldChange<FreeBusy> OnFreeBusyChange
Event Type
Type | Description |
---|---|
OnFieldChange<FreeBusy> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnGroupIdxChange
Event raised when GroupIdx is changing.
Declaration
public event OnFieldChange<int> OnGroupIdxChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnHasAlarmChange
Event raised when HasAlarm is changing.
Declaration
public event OnFieldChange<short> OnHasAlarmChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnInternalNotesTextIdChange
Event raised when InternalNotesTextId is changing.
Declaration
public event OnFieldChange<int> OnInternalNotesTextIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnInvitedPersonIdChange
Event raised when InvitedPersonId is changing.
Declaration
public event OnFieldChange<int> OnInvitedPersonIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnIsMilestoneChange
Event raised when IsMilestone is changing.
Declaration
public event OnFieldChange<short> OnIsMilestoneChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnJoinVideomeetUrlChange
Event raised when JoinVideomeetUrl is changing.
Declaration
public event OnFieldChange<string> OnJoinVideomeetUrlChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnLagTimeChange
Event raised when LagTime is changing.
Declaration
public event OnFieldChange<short> OnLagTimeChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnLeadtimeChange
Event raised when Leadtime is changing.
Declaration
public event OnFieldChange<short> OnLeadtimeChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnLocationChange
Event raised when Location is changing.
Declaration
public event OnFieldChange<string> OnLocationChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnModifiedAppointmentFieldsChange
Event raised when ModifiedAppointmentFields is changing.
Declaration
public event OnFieldChange<ModifiedAppointmentFields> OnModifiedAppointmentFieldsChange
Event Type
Type | Description |
---|---|
OnFieldChange<ModifiedAppointmentFields> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnMotherAssociateIdChange
Event raised when MotherAssociateId is changing.
Declaration
public event OnFieldChange<int> OnMotherAssociateIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnMotherIdChange
Event raised when MotherId is changing.
Declaration
public event OnFieldChange<int> OnMotherIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnOriginalStartDateChange
Event raised when OriginalStartDate is changing.
Declaration
public event OnFieldChange<DateTime> OnOriginalStartDateChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnOwnedExternallyChange
Event raised when OwnedExternally is changing.
Declaration
public event OnFieldChange<AppointmentExternalOwner> OnOwnedExternallyChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentExternalOwner> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnPersonIdChange
Event raised when PersonId is changing.
Declaration
public event OnFieldChange<int> OnPersonIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnPreferredTZLocationChange
Event raised when PreferredTZLocation is changing.
Declaration
public event OnFieldChange<int> OnPreferredTZLocationChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnPriorityIdxChange
Event raised when PriorityIdx is changing.
Declaration
public event OnFieldChange<int> OnPriorityIdxChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnPrivateChange
Event raised when Private is changing.
Declaration
public event OnFieldChange<AppointmentPrivate> OnPrivateChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentPrivate> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnProjectIdChange
Event raised when ProjectId is changing.
Declaration
public event OnFieldChange<int> OnProjectIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnRecurrenceRuleIdChange
Event raised when RecurrenceRuleId is changing.
Declaration
public event OnFieldChange<int> OnRecurrenceRuleIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnRegisteredAssociateIdChange
Event raised when RegisteredAssociateId is changing.
Declaration
public event OnFieldChange<int> OnRegisteredAssociateIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnRegisteredChange
Event raised when Registered is changing.
Declaration
public event OnFieldChange<DateTime> OnRegisteredChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnRejectCounterChange
Event raised when RejectCounter is changing.
Declaration
public event OnFieldChange<short> OnRejectCounterChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnRejectReasonChange
Event raised when RejectReason is changing.
Declaration
public event OnFieldChange<string> OnRejectReasonChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnSaleIdChange
Event raised when SaleId is changing.
Declaration
public event OnFieldChange<int> OnSaleIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnSendEmailChange
Event raised when SendEmail is changing.
Declaration
public event OnFieldChange<short> OnSendEmailChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnSourceChange
Event raised when Source is changing.
Declaration
public event OnFieldChange<short> OnSourceChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnStatusChange
Event raised when Status is changing.
Declaration
public event OnFieldChange<AppointmentStatus> OnStatusChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentStatus> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnSuggestedAppointmentIdChange
Event raised when SuggestedAppointmentId is changing.
Declaration
public event OnFieldChange<int> OnSuggestedAppointmentIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnSuggestedDocumentIdChange
Event raised when SuggestedDocumentId is changing.
Declaration
public event OnFieldChange<int> OnSuggestedDocumentIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnTaskIdxChange
Event raised when TaskIdx is changing.
Declaration
public event OnFieldChange<int> OnTaskIdxChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnTextIdChange
Event raised when TextId is changing.
Declaration
public event OnFieldChange<int> OnTextIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnTypeChange
Event raised when Type is changing.
Declaration
public event OnFieldChange<AppointmentType> OnTypeChange
Event Type
Type | Description |
---|---|
OnFieldChange<AppointmentType> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnUpdatedAssociateIdChange
Event raised when UpdatedAssociateId is changing.
Declaration
public event OnFieldChange<int> OnUpdatedAssociateIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnUpdatedChange
Event raised when Updated is changing.
Declaration
public event OnFieldChange<DateTime> OnUpdatedChange
Event Type
Type | Description |
---|---|
OnFieldChange<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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnUpdatedCountChange
Event raised when UpdatedCount is changing.
Declaration
public event OnFieldChange<short> OnUpdatedCountChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int16> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnUserdef2IdChange
Event raised when Userdef2Id is changing.
Declaration
public event OnFieldChange<int> OnUserdef2IdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnUserdefIdChange
Event raised when UserdefId is changing.
Declaration
public event OnFieldChange<int> OnUserdefIdChange
Event Type
Type | Description |
---|---|
OnFieldChange<Int32> |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|
OnValueChanged
Tasks, appointments, followups, phone calls; and documents (document_id != 0). An appointment always has a corresponding record in VisibleFor specifying who may see this.
Row Object for table 'appointment'. 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 event OnTableValueChange OnValueChanged
Event Type
Type | Description |
---|---|
OnTableValueChange |
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
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) AppointmentRow AppointmentRow.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(AppointmentRow.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
and 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 AppointmentTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AppointmentTableInfo) 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.
Index fields | Nested index class name |
---|