Add Strategy | Ruby API Client V1 (Deprecated)

1
// Not implemented in Ruby client v1

1
2
3
4
5
6
7
8
9
10
11
12
13
recommendation.setPersonalizationStrategy({
  eventsScoring: [
    { eventName: 'Add to cart', eventType: 'conversion', score: 50 },
    { eventName: 'Purchase', eventType: 'conversion', score: 100 },
  ],
  facetsScoring: [
    { facetName: 'brand', score: 100 },
    { facetName: 'categories', score: 10 },
  ],
  personalizationImpact: 50,
}).then(() => {
  // done
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
recommendation.set_personalization_strategy({
    'eventsScoring': [
        {
            'eventName': 'Add to cart',
            'eventType': 'conversion',
            'score': 50
        },
        {
            'eventName': 'Purchase',
            'eventType': 'conversion',
            'score': 100
        },
    ],
    'facetsScoring': [
        {'facetName': 'brand', 'score': 100},
        {'facetName': 'categories', 'score': 10},
    ],
    'personalizationImpact': 50,
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
let recommendationClient = RecommendationClient(appID: "YourApplicationID", apiKey: "YourAPIKey")

let eventsScoring: [EventScoring] = [
  .init(eventName: "Add to cart", eventType: .conversion, score: 50),
  .init(eventName: "Purchase", eventType: .conversion, score: 100)
]

let facetsScoring: [FacetScoring] = [
  .init(facetName: "brand", score: 100),
  .init(facetName: "categories", score: 10)
]

let strategy = PersonalizationStrategy(eventsScoring: eventsScoring,
                                       facetsScoring: facetsScoring,
                                       personalizationImpact: 0)

recommendationClient.setPersonalizationStrategy(strategy) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var strategy = new SetStrategyRequest
{
    EventsScoring =
        new List<EventsScoring>
        {
            new EventsScoring("Add to cart", "conversion", 50),
            new EventsScoring("Purchase", "conversion", 100)
        },
    FacetsScoring = new List<FacetsScoring>
    {
        new FacetsScoring("brand", 100),
        new FacetsScoring("categories", 10)
    },
    PersonalizationImpact = 50
};

client.SetPersonalizationStrategy(strategy);

1
2
3
4
5
6
7
8
9
10
11
12
13
SetStrategyRequest strategy = new SetStrategyRequest()
        .setEventsScoring(Arrays.asList(
                new EventsScoring("Add to cart", "conversion", 50),
                new EventsScoring("Purchase", "conversion", 100)
        ))
        .setFacetsScoring(Arrays.asList(
                new FacetsScoring("brand", 100),
                new FacetsScoring("categories", 10)
        ))
        .setPersonalizationImpact(50);


client.setPersonalizationStrategy(strategy);

1
2
3
4
5
6
7
8
9
10
11
12
13
strategy := recommendation.Strategy{
    EventsScoring: []recommendation.EventsScoring{
        {"Add to cart", "conversion", 50},
        {"Purchase", "conversion", 100},
    },
    FacetsScoring: []recommendation.FacetsScoring{
        {"brand", 100},
        {"categories", 10},
    },
    PersonalizationImpact: opt.PersonalizationImpact(50),
}

res, err := client.SetPersonalizationStrategy(strategy)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
val strategy = SetStrategyRequest(
  eventsScoring = Seq(
    EventsScoring("Add to cart", "conversion", 50),
    EventsScoring("Purchase", "conversion", 100)
  ),
  facetsScoring = Seq(
    FacetsScoring("brand", 100),
    FacetsScoring("categories", 10)
  ),
  personalizationImpact = 50
)

client.execute {
  set personalizationRecommendationStrategy strategy
}

1
2
3
4
5
6
7
8
9
10
11
12
13
val strategy = PersonalizationStrategy(
    eventsScoring = listOf(
        EventScoring("Add to cart", "conversion", 50),
        EventScoring("Purchase", "conversion", 100)
    ),
    facetsScoring = listOf(
        FacetScoring("brand", 100),
        FacetScoring("categories", 10)
    ),
    personalizationImpact = 50
)

clientRecommendation.setPersonalizationStrategy(strategy)