Class PotentialDuplicate

KeyValuePairs

HasValue

• get HasValue(): boolean

  Utility function to check if the composite key has any values set

  Returns boolean

StaticDefaultFieldDelimiter

• get DefaultFieldDelimiter(): string

  Default delimiter for separating fields in a string that represents a key value pair within the composite key

  Returns string

StaticDefaultValueDelimiter

• get DefaultValueDelimiter(): string

  Default delimiter for separating values from field names in a string that represents a key value pair within the composite key

  Returns string

Copy

• Copy(): CompositeKey

  Utility function to return a copy of the CompositeKey with the Value properties as string

  Returns CompositeKey

  a copy of the KeyValuePairs array but with the Value properties as string

Equals

• Equals(compositeKey: CompositeKey): boolean

  Utility function to compare this composite key to another

  Parameters

  • compositeKey: CompositeKey

    the composite key to compare against

  Returns boolean

  true if the primary key values are the same, false if they are different

EqualsKey

• EqualsKey(kvPairs: KeyValuePair[]): boolean

  Utility function to compare the key primary key of this object to another sets to see if they are the same or not

  Parameters

  • kvPairs: KeyValuePair[]

    the primary key values to compare against

  Returns boolean

  true if the primary key values are the same, false if they are different

GetValueByFieldName

• GetValueByFieldName(fieldName: string): any

  returns the value of the key value pair for the specified field name

  Parameters

  • fieldName: string

    the field name to get the value for

  Returns any

  the value of the key value pair for the specified field name

GetValueByIndex

• GetValueByIndex(index: number): any

  returns the value of the key value pair at the specified index

  Parameters

  • index: number

    the index of the key value pair to get the value for

  Returns any

  the value of the key value pair at the specified index

LoadFromConcatenatedString

• LoadFromConcatenatedString(
      concatenatedString: string,
      fieldDelimiter?: string,
      valueDelimiter?: string,
  ): void

  Utility to load the object from a string representation of the key value pairs in the format "Field1|Value1||Field2|Value2" etc. The delimiters between the fields default to '||' and the values default to '|', but can be anything desired.

  Parameters

  • concatenatedString: string
  • fieldDelimiter: string = '||'
  • valueDelimiter: string = '|'

  Returns void

LoadFromEntityFields

• LoadFromEntityFields(fields: EntityField[]): void

  Parameters

  • fields: EntityField[]

  Returns void

LoadFromEntityInfoAndRecord

• LoadFromEntityInfoAndRecord(entity: EntityInfo, entityRecord: any): void

  Parameters

  • entity: EntityInfo
  • entityRecord: any

  Returns void

LoadFromList

• LoadFromList(list: string[], delimiter?: string): void

  Loads the KeyValuePairs from a list of strings in the format "FieldName=Value"

  Parameters

  • list: string[]

    the list of strings to load from

  • Optionaldelimiter: string

    the delimiter to use between the field name and value. Defaults to '='

  Returns void

  Example

  ["ID=1", "Name=John"]
  Copy

LoadFromSimpleObject

• LoadFromSimpleObject(obj: any): void

  Loads from a simple object by extracting the key value pairs from the object

  Parameters

  • obj: any

  Returns void

LoadFromSingleKeyValuePair

• LoadFromSingleKeyValuePair(fieldName: string, value: any): void

  Loads the key from a single key value pair

  Parameters

  • fieldName: string
  • value: any

  Returns void

LoadFromURLSegment

• LoadFromURLSegment(entity: EntityInfo, urlSegment: string): void

  Parses a provided url segment using the provided delimiter and loads the key value pairs from it. If the segment just contains a single value and no delimiter, it will assume the field name is the primary key field name of the entity and load that way.

  Parameters

  • entity: EntityInfo
  • urlSegment: string

  Returns void

SimpleLoadFromURLSegment

• SimpleLoadFromURLSegment(urlSegment: string): void

  Parses the provided routeSegment and assumes the field names are included in the segment

  Parameters

  • urlSegment: string

  Returns void

ToConcatenatedString

• ToConcatenatedString(fieldDelimiter?: string, valueDelimiter?: string): string

  Utility to generate a string representation of the key value pairs in the format "Field1|Value1||Field2|Value2" etc. The field delimiter defaults to '||' and the value delimiter defaults to '|'

  Parameters

  • fieldDelimiter: string = '||'
  • valueDelimiter: string = '|'

  Returns string

ToList

• ToList(delimiter?: string): string[]

  Parameters

  • Optionaldelimiter: string

    the delimiter to use between the field name and value. Defaults to '='

  Returns string[]

  the KeyValuePairs as a list of strings in the format "FieldName=Value"

  Example

  ["ID=1", "Name=John"]
  Copy

ToString

• ToString(useIsNull?: boolean): string

  Parameters

  • OptionaluseIsNull: boolean

    if true, will return "FieldName IS NULL" for any key value pair that has a null or undefined value

  Returns string

  a string representation of the primary key values in the format "FieldName=Value"

  Example

  "ID=1 AND Name=John"
  Copy

ToURLSegment

• ToURLSegment(segment?: string): string

  For URL segments, we use | and || as the standard delimiters for field and value respectively in order to avoid conflicts with the standard URL delimiters like = and &. This method converts the key value pairs to a URL segment

  Parameters

  • Optionalsegment: string

  Returns string

ToWhereClause

• ToWhereClause(useIsNull?: boolean, quoteStyle?: "single" | "double"): string

  Utility function to return a string representation of the composite key in the format "FieldName=Value AND FieldName=Value"

  Parameters

  • useIsNull: boolean = true

    if true, will return "FieldName IS NULL" for any key value pair that has a null or undefined value, if false, will return "FieldName=Value"

  • quoteStyle: "single" | "double" = 'single'

  Returns string

  a string representation of the composite key in the format "FieldName=Value AND FieldName=Value"

  Example

  "ID=1 AND Name='John'"
  Copy

Validate

• Validate(
      entity?: EntityInfo,
      primaryKey?: boolean,
  ): { ErrorMessage: string; IsValid: boolean }

  Helper method to check if the underlying key value pairs are valid or not i.e. if any of the key value pairs are null or undefined

  Parameters

  • Optionalentity: EntityInfo

    If provided, this method will validate that the composite key is valid for the given entity as a primary key or alternate key.

  • primaryKey: boolean = true

    If set to true, and entity is provided, this method will validate that the composite key is valid as the primary key for the given entity.

  Returns { ErrorMessage: string; IsValid: boolean }

  true if all key value pairs are valid, false if any are null or undefined

Values

• Values(delimiter?: string): string

  Parameters

  • Optionaldelimiter: string

    the delimiter to use between the values. Defaults to ', '

  Returns string

  the value of each key value pair in the format "Value1, Value2, Value3"

  Example

  "1, John"
  Copy

ValuesAsString

• ValuesAsString(): KeyValuePair[]

  Returns KeyValuePair[]

  a copy of the KeyValuePairs array but with the Value properties as type string

StaticEqualsEx

• EqualsEx(
      key1: CompositeKey | CompositeKey[],
      key2: CompositeKey | CompositeKey[],
  ): boolean

  Utility function to compare either single composite keys or arrays of composite keys. When comparing arrays, both order and content must match.

  Parameters

  • key1: CompositeKey | CompositeKey[]

    First key or array of keys to compare

  • key2: CompositeKey | CompositeKey[]

    Second key or array of keys to compare

  Returns boolean

  true if the keys are equal, false otherwise. Returns false if types don't match (single vs array).

StaticFromID

• FromID(id: any): CompositeKey

  Many entities have a single primary key field called ID, this utility method allows you to create a CompositeKey from just that ID value.

  Parameters

  • id: any

  Returns CompositeKey

StaticFromKeyValuePair

• FromKeyValuePair(key: string, value: any): CompositeKey

  Static factory method to create a CompositeKey from a single key value pair.

  Parameters

  • key: string
  • value: any

  Returns CompositeKey

StaticFromKeyValuePairs

• FromKeyValuePairs(keyValuePairs: KeyValuePair[]): CompositeKey

  Static factory method to create a CompositeKey from an array of key value pairs. Mirrors the constructor but allows for a more explicit creation of a CompositeKey from an array of KeyValuePair objects.

  Parameters

  • keyValuePairs: KeyValuePair[]

  Returns CompositeKey

StaticFromObject

• FromObject(obj: any): CompositeKey

  Creates a CompositeKey from a simple object where the keys are the field names and the values are the values.

  Parameters

  • obj: any

  Returns CompositeKey