Get related products

1
2
3
4
5
6
recommendations = recommend_client.get_related_products([
    {
        indexName: "your_index_name",
        objectID: "your_object_id"
    }
])

1
2
3
4
5
6
7
8
9
10
11
12
recommendClient.getRelatedProducts([
  {
    indexName: 'your_index_name',
    objectID: 'your_object_id',
  },
])
.then(({ results }) => {
  console.log(results);
})
.catch(err => {
  console.log(err);
});

1
2
3
4
5
6
7
8
related_products = recommend_client.get_related_products(
  [
      {
          "indexName": "your_index_name",
          "objectID": "your_object_id",
      },
  ]
);

1
2
3
4
5
6
let options = RelatedProductsOptions(indexName: "IndexName", objectID: "B018APC4LE")
recommendClient.getRelatedProducts(options: [options]) { result in 
 if case .success(let response) = result {
   print("Response: \(response)")
 }
}

1
2
3
4
5
6
val request = RelatedProductsQuery(
    indexName = IndexName("yourIndexName"),
    objectID = ObjectID("yourObjectID"),
)

recommendClient.getRelatedProducts(requests = listOf(request))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Product
{
    public string ObjectID { get; set; }
    public string Name { get; set; }
    public string Category { get; set; }
    public float Price { get; set; }
}

public class RelatedProduct : Product, Algolia.Search.Models.Recommend.IRecommendHit
{
    public float Score { get; set; }
}

var requests = new List<Algolia.Search.Models.Recommend.RelatedProductsRequest> {
  new Algolia.Search.Models.Recommend.RelatedProductsRequest {
      IndexName = "your_index_name",
      ObjectID = "your_object_id",
  }
}

var relatedProducts =
  recommendClient.GetRelatedProducts<RelatedProduct>(requests);

// Asynchronous
var relatedProducts =
  await recommendClient.GetRelatedProductsAsync<RelatedProduct>(requests);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Product implements RecommendHit {
   String objectID;
   String name;
   Float score;

   @Nonnull
   @Override
   public Float getScore() { return score;}
   public void setScore(Float score) { this.score = score;}
     
   public String getObjectID() { return objectID; }
   public void setObjectID(String objectID) { this.objectID = objectID; }
     
   public String getName() { return name; }
   public void setName(String name) { this.name = name; }
 }

 RelatedProductsQuery query = new RelatedProductsQuery("yourIndexName", "yourObjectID");

 // Synchronous
 List<RecommendationsResult<Product>> recommendations = recommendClient.getRelatedProducts(Arrays.asList(query), Product.class);

 // Asynchronous
 CompletableFuture<List<RecommendationsResult<Product>>> recommendations = recommendClient.getRelatedProductsAsync(Arrays.asList(query), Product.class);

1
2
options := recommend.NewRelatedProductsOptions("IndexName", "B018APC4LE", 0, nil, nil, nil)
res, err = recommendClient.GetRelatedProducts([]recommend.RelatedProductsOptions{options})

1
2
3
4
5
6
7
recommendClient.execute {
   val query = RelatedProductsQuery(
     indexName = "yourIndexName",
     objectID = "yourObjectID"
   )
   get relatedProducts  List(query)
 }