[[Service - Search Results]]

= reqiuredData structure =
* requiredData as array that have multiple feildName to findData

<syntaxhighlight lang="js">

[
{
fieldName: "fieldname if main objType or last fieldName for linkPath",
combinationComplexFilter: {
[combinationA]: {
//* complexFilter as normalize structure
}
},
linkPath: [
{
link: {
objType: {
serviceTag: "ServciceTag",
objectType: "linkObjectType1"
},
relType: {
serviceTag: "ServiceTag",
objectType: "hasLinkObjectType1"
},
direction: "to" | "from",
requestProperties: {
orderQuantity: 2,
//...
}
},
//== condition ==
filterElements: [],
aggregate: "max" | "min" | "average",
sortFields: {
fieldName: "fieldname if main objType or last fieldName for linkPath",
dataType: "string" | "number" | "array"
},
combine: true | false,
perParentComplexFilters: {
[combinationTagB]: {
//* complexFilter as normalize structure
}
},
applyCombinations: [
//* tag only in combinationComplexFilters
"combinationTagA"
],
comparison: "lessThan" | "gearterThan" | "lessThanEquals" | "greaterThanEquals" | "high" | "low" | "highLow",
comparisonValue: "value",
comparisonSortField: "fieldName"
},
//...
]
}
]

</syntaxhighlight>

== example ==

<syntaxhighlight lang="js">

[
{
fieldName: "price",
combinationComplexFilters: {
locationNode: {
//* complexFilter as normalize structure
}
},
linkPath: [
{
link: {
objType: {
serviceTag: "SellOfferManager",
objectType: "sellOffer"
},
relType: {
serviceTag: "SellOfferManager",
objectType: "sellOffer"
},
direction: "from",
requestProperties: {
orderQuantity: 2,
//...
}
},
filterElements: [ //* must change to normalize structure
{
type: "logical", //example
fieldName: "price",
comparison: "greaterThan",
value: 50
},
{
type: "complexFilter",
complexFilter: {
objType: {
serviceTag: "SellOfferManager",
objectType: "sellOffer"
}
//...
//.. maybe ref. from main filter
}
},
//...
]
},
{
link: {
objType: {
serviceTag: "SellOfferManager",
objectType: "sellOffer"
},
relType: {
serviceTag: "SellOfferManager",
objectType: "hasOrderPrice"
},
direction: "from",
requestProperties: {
orderQuantity: 2,
deliveryMethodIds: [
"deliveryMethodId_chiangMai"
]
//...
}
},
//== condition ==
//filterElements
aggregate: "max",
sortFields: {
fieldName: "price",
dataType: "number"
},
combine: true,
perParentComplexFilters: {
sellOfferPlan: {
//* complexFilter as normalize structure
},
sellOfferPlanDeliveryMethodLink: {
//* complexFilter as normalize structure
},
sellOfferPlanUserPaymentMethodLink: {
//* complexFilter as normalize structure
}
},
applyCombinations: [
//* tag only in combinationComplexFilters
"locationNode"
],
// comparison: "greaterThan",
// comparisonValue: "50",
// comparisonSortField: "upToValue"
},
//...
]
},
//...
]

</syntaxhighlight>

== ProcessSearchResultMessage ==
* Fetch and Sort Product Sizes by Language with Fallback
<syntaxhighlight lang="js">

Need to fetch all sizes, sorted by language order 'en', 'th'.
If a translation is missing for any language in sortArray: ['en', 'th'],
fallback to the defaultTranslationLink of that productAttribute.
ProductAttributeLabel with labelId = 'Id_X' represents a size.
identifiersIdArray contains all productAttributeIds linked to ProductAttributeLabel where labelId='Id_X'.
</syntaxhighlight>

<syntaxhighlight lang="js">

let processSearchResultMessage = {
objType: {
serviceTag: 'ProductAttribute',
objectType: 'productAttribute'
},
requiredData: [
{
fieldName: 'text', //all sizes by languageId, where text is the identifiers of the translation objectType, which is the final link step of this requiredData
linkPath: [
{
link: {
relType: {
serviceTag: 'Translations',
relationshipTag: 'hasTranslationLink'
// Must use hasTranslationLink because it will be automatically added by inserting a filterElement with logicalType: "translateIds"
// where identifiers come from identifiersIdArray (Process-ComplexFilter), along with a filterElement of type: "logicalOperator" and operator: "and"
},
objType: {
serviceTag: 'Translations',
objectType: 'translationLink'
},
direction: 'from'
},
aggregate: 'min', //if 'min' sorts languages in order 'en', 'th', //if max sorts languages in order 'th', 'en
sortFields: {
fieldName: 'languageId',
dataType: 'array',
sortArray: ['en', 'th'] // sorts languages according to sortArray
},
filterElements: [
{
type: 'group',
elements: [
{
type: 'traversal',
traversals: [
{
fields: {
languageId: { anyValue: ['en', 'th'] },
textTag: 'productAttributeValue'
},
link: {
relationshipDirection: 'from',
relType: {
serviceTag: 'Translations',
relationshipTag: 'currentTranslationLink'
}
}
},
{
objType: {
serviceTag: 'ProductAttribute',
objectType: 'productAttribute'
}
}
]
},
{
type: 'logicalOperator', operator: 'or'
},
{
type: 'traversal',
traversals: [
{
fields: {
textTag: 'productAttributeValue'
},
link: {
relationshipDirection: 'from',
relType: {
serviceTag: 'Translations',
relationshipTag: 'defaultTranslationLink'
}
}
},
{
objType: {
serviceTag: 'ProductAttribute',
objectType: 'productAttribute'
}
}
]
}
]
}
]
},
{
link: {
relType: {
serviceTag: 'Translations',
relationshipTag: 'isTranslation'
},
objType: {
serviceTag: 'Translations',
objectType: 'translation'
},
direction: 'from'
}
}
]
}
],
filter: {
objType: {
serviceTag: 'ProductAttribute',
objectType: 'productAttribute'
},
elements: [
{
type: 'complexFilter',
complexFilter: {
objType: {
serviceTag: 'ProductAttribute',
objectType: 'ProductAttributeLabel'
},
relType: {
serviceTag: 'ProductAttribute',
relationshipTag: 'isProductAttributeLabel'
},
direction: 'from',
elements: [
{
type: 'logical',
fieldName: 'labelId',
comparison: 'equals',
value: 'Id_X'
}
]
}
}
]
},
requestProperties: {},
identifiersIdArray: [
{
identifiersId: 'hashOfIdentifiersObject_1',
identifiers: {
productAttributeId: 'productAttributeId_uuid_1'
}
},
{
identifiersId: 'hashOfIdentifiersObject_2',
identifiers: {
productAttributeId: 'productAttributeId_uuid_2'
}
},
{
identifiersId: 'hashOfIdentifiersObject_3',
identifiers: {
productAttributeId: 'productAttributeId_uuid_3'
}
}
]
}

</syntaxhighlight>

[[Category:Working documents| 2025-04-17]]
[[Category:Working documents - Search Results| 2025-04-17]]

2025-01-23 - Standard Object and Relationship Data Structures

2025-06-03T10:26:57Z

Olive:

= Overview =
Standard structure and definition of object.

= Definition =

== objType ==
<syntaxhighlight lang="JavaScript">
{
serviceTag: "xxx",
objectType: "yyy"
}
</syntaxhighlight>
use to identify which serviceTag that object schema located
* serviceTag: service tag that stored object schema
* objectType: name of object schema

== objTypeConcat ==
<syntaxhighlight lang="JavaScript">
<serviceTag>_<objectType>
</syntaxhighlight>
* objTypeConcat: "serviceTag" + "_" + "objectType"
* now use as the name of node label in graph database

== objTypeId ==
* hash of objType object

== relType ==
<syntaxhighlight lang="JavaScript">
{
serviceTag: "xxx",
relationshipTag: "yyy"
}
</syntaxhighlight>
use to identify which serviceTag that relationship schema located
* serviceTag: service tag that stored object schema
* relationshipTag: name of relationship schema

== relTypeConcat ==
<syntaxhighlight lang="JavaScript">
<serviceTag>_<relationshipTag>
</syntaxhighlight>
* relTypeConcat: "serviceTag" + "_" + "relationshipTag"
* now use as the name of relationshipType in graph database

== relTypeId ==
* hash of relType object

== relTypeAndDirection ==
<syntaxhighlight lang="JavaScript">
{
relType: {
serviceTag: "xxx",
relationshipTag: "yyy"
},
relationshipDirection: "to" // "from" || "to"
}
</syntaxhighlight>

== linkType ==
<syntaxhighlight lang="JavaScript">
{
firstObjType: {
serviceTag: "xx",
objectType: "yy",
},
secondObjType: {
serviceTag: "xxx",
objectType: "yyy"
},

relType: {
serviceTag: "xxxx",
relationshipTag: "yyyy"
},
relationshipDirection: "to" // "from" || "to"
}
</syntaxhighlight>
use to identify relationship between 2 objectSchema

== linkTypeId ==
create hash id from linkType

== pathLinkType ==
<syntaxhighlight lang="JavaScript">
{
objType: {
serviceTag: "xxx",
objectType: "yyy"
},
relType: {
serviceTag: "xxxx",
relationshipTag: "yyyy"
},
relationshipDirection: "to" // "from" || "to"
}
</syntaxhighlight>
* pathLinkType is used at each step of traversal/path
* when joined with the previous objType/baseObjType can be used to create linkType (and request linkConfig)

== flowType ==
<syntaxhighlight lang="JavaScript">
{
serviceTag: "xxx",
flowTag: "yyy"
}
</syntaxhighlight>
use to identify which serviceTag that flow schema is located

== identifiers ==
An object that has fieldName’s identifiers inside
=== example identifiers ===
* example identifiers inside objectSchema
<syntaxhighlight lang="JavaScript">
identifiers:[
{
type: "partitionKey",
fieldNames: ["xx","yy"],
name: "zz"
}
]
</syntaxhighlight>
* example identifiers object
<syntaxhighlight lang="JavaScript">
{
xx:"xx value",
yy:"yy value"
}
</syntaxhighlight>

The example above identifiers is the value of fieldNames that part of identifiers

== identifiersBase ==
concatenated identifiers object
=== example identifiersBase ===
* example identifiers inside objectSchema
<syntaxhighlight lang="JavaScript">
identifiers:[
{
type: "partitionKey",
fieldNames: ["xx","yy"],
name: "zz"
}
]
</syntaxhighlight>
* example identifiersBase object
<syntaxhighlight lang="JavaScript">
{
zz:"xxValue_yyValue",
}
</syntaxhighlight>

The example above identifiersBase is the value of each identifier of objectSchema

== identifiersId ==
hash of identifiers object

== identifiersConcat ==
string that concatenate all identifiers
* Note!: Will ordered concatenate value by objectSchema.identifiers array

== objInstanceBase ==
result from dynamoDB that contains relevant and not relevant data of objectSchema
* identifiers from in objInstanceBase will concatenated or not concatenated depending on objectSchema
* izContext field not relevant with objectSchema but it contains inside objInstanceBase

== objInstance ==
similar objInstanceBase but split concatenateIdentifier to each fieldName

== objInstanceFull ==
object that separated fields and identifiers and identifiers cannot concatenated
<syntaxhighlight lang="JavaScript">
{
identifiers:{
//... identifiers fieldName of objectSchema
},
fields:{
//.. data of objectSchema
}
}
</syntaxhighlight>
* identifiers: contains identifiers data
* fields: another data except

== example data ==
=== example objectSchema ===
<syntaxhighlight lang="JavaScript">
// example objectSchema
{
fieldNames:{
id:{
type:”string”,
// … another fieldName settings
},
createTime: {}, // filedName settings
location: {}, // filedName settings
value: {}, // filedName settings
},
identifiers:[
{
type: "partitionKey",
fieldNames: ["id","createTime"], // composite partition keys in DynamoDB
deliminator: "_", // optional, defaults to "_"
name: "createId" // name of field in database
},
{
type: "sortKey",
fieldName: “location”
}
]
}
</syntaxhighlight>

=== objInstanceBase ===
<syntaxhighlight lang="JavaScript">
// example objInstanceBase data
{
createId:"id_createTime",
location:"cnx",
value:199,
errorsFound:[],
izContext:{
// ...izContext
},
}
</syntaxhighlight>
Normally objInstanceBase is the result from dynamoDB and it will include data that is not relevant to objectSchema. In example above errorsFound and izContext not contain in objectSchema.

=== objInstance ===
<syntaxhighlight lang="JavaScript">
// example objInstance data
{
id:"id",
createTime:"createTime"
location:"cnx",
value:199,
errorsFound:[],
izContext:{
// ...izContext
},
}
</syntaxhighlight>
objInstance is object that already refactored identifiers but another fields same as objInstanceBase

=== objInstanceFull ===
<syntaxhighlight lang="JavaScript">
// example objInstanceFull data
{
identifiers:{
id:"id",
createTime:"createTime"
location:"cnx",
},
fields:{
value:199,
}
}
</syntaxhighlight>

=== identifiersBase ===
<syntaxhighlight lang="JavaScript">
// example identifiersBase data
{
createId:"id_createTime",
location:"cnx"
}
</syntaxhighlight>

=== identifiers ===
<syntaxhighlight lang="JavaScript">
// example identifiers data
{
id: "id",
createTime: "createTime",
location: "cnx"
}
</syntaxhighlight>

[[Category:Working documents| 2025-01-23]]
[[Category:Working documents - Per Service Schemas| 2025-01-23]]