Get frequently bought together

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

1
2
3
4
5
6
7
8
9
10
11
12
recommendClient.getFrequentlyBoughtTogether([
  {
    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
recommendations = recommend_client.get_frequently_bought_together(
  [
      {
          "indexName": "your_index_name",
          "objectID": "your_object_id",
      },
  ]
);

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

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

recommendClient.getFrequentlyBoughtTogether(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 RecommendedProduct : Product, Algolia.Search.Models.Recommend.IRecommendHit
{
    public float Score { get; set; }
}

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

var recommendations =
  recommendClient.GetFrequentlyBoughtTogether<RecommendedProduct>(requests);

// Asynchronous
var recommendations =
  await recommendClient.GetFrequentlyBoughtTogetherAsync<RecommendedProduct>(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; }
 }

 FrequentlyBoughtTogetherQuery query = new FrequentlyBoughtTogetherQuery("yourIndexName", "yourObjectID");
 
 // Synchronous
 List<RecommendationsResult<Product>> recommendations = recommendClient.getFrequentlyBoughtTogether(Arrays.asList(query), Product.class);
 
 // Asynchronous
 CompletableFuture<List<RecommendationsResult<Product>>> recommendations = recommendClient.getFrequentlyBoughtTogetherAsync(Arrays.asList(query), Product.class);

1
2
options := recommend.NewBoughtTogetherOptions("IndexName", "B018APC4LE", 0, nil, nil)
 res, err = recommendClient.GetFrequentlyBoughtTogether([]recommend.FrequentlyBoughtTogetherOptions{options})

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