Add or update a composition rule

// Initialize the client
var client = new CompositionClient(
  new CompositionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
);

// Call the API
var response = await client.PutCompositionRuleAsync(
  "compositionID",
  "rule-with-deduplication",
  new CompositionRule
  {
    ObjectID = "rule-with-deduplication",
    Description = "my description",
    Enabled = true,
    Conditions = new List<Condition>
    {
      new Condition { Anchoring = Enum.Parse<Anchoring>("Contains"), Pattern = "harry" },
    },
    Consequence = new CompositionRuleConsequence
    {
      Behavior = new CompositionBehavior(
        new CompositionInjectionBehavior
        {
          Injection = new Injection
          {
            Main = new InjectionMain
            {
              Source = new InjectionMainSource(
                new InjectionMainSearchSource { Search = new MainSearch { Index = "my-index" } }
              ),
            },
            InjectedItems = new List<InjectionInjectedItem>
            {
              new InjectionInjectedItem
              {
                Key = "my-unique-injected-item-key",
                Source = new InjectedItemSource(
                  new InjectedItemSearchSource
                  {
                    Search = new InjectedItemSearch { Index = "my-index" },
                  }
                ),
                Position = 0,
                Length = 3,
              },
            },
            Deduplication = new Deduplication
            {
              Positioning = Enum.Parse<DedupPositioning>("HighestInjected"),
            },
          },
        }
      ),
    },
  }
);

// print the response
Console.WriteLine(response);

// Initialize the client
final client = CompositionClient(
    appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

// Call the API
final response = await client.putCompositionRule(
  compositionID: "compositionID",
  objectID: "rule-with-deduplication",
  compositionRule: CompositionRule(
    objectID: "rule-with-deduplication",
    description: "my description",
    enabled: true,
    conditions: [
      Condition(
        anchoring: Anchoring.fromJson("contains"),
        pattern: "harry",
      ),
    ],
    consequence: CompositionRuleConsequence(
      behavior: CompositionInjectionBehavior(
        injection: Injection(
          main: InjectionMain(
            source: InjectionMainSearchSource(
              search: MainSearch(
                index: "my-index",
              ),
            ),
          ),
          injectedItems: [
            InjectionInjectedItem(
              key: "my-unique-injected-item-key",
              source: InjectedItemSearchSource(
                search: InjectedItemSearch(
                  index: "my-index",
                ),
              ),
              position: 0,
              length: 3,
            ),
          ],
          deduplication: Deduplication(
            positioning: DedupPositioning.fromJson("highestInjected"),
          ),
        ),
      ),
    ),
  ),
);

// print the response
print(response);

// Initialize the client
client, err := composition.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
if err != nil {
  // The client can fail to initialize if you pass an invalid parameter.
  panic(err)
}

// Call the API
response, err := client.PutCompositionRule(client.NewApiPutCompositionRuleRequest(
  "compositionID", "rule-with-deduplication",
  composition.NewEmptyCompositionRule().SetObjectID("rule-with-deduplication").SetDescription("my description").SetEnabled(true).SetConditions(
    []composition.Condition{
      *composition.NewEmptyCondition().SetAnchoring(composition.Anchoring("contains")).SetPattern("harry"),
    }).
    SetConsequence(
      composition.NewEmptyCompositionRuleConsequence().SetBehavior(composition.CompositionInjectionBehaviorAsCompositionBehavior(
        composition.NewEmptyCompositionInjectionBehavior().SetInjection(
          composition.NewEmptyInjection().SetMain(
            composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
              composition.NewEmptyInjectionMainSearchSource().SetSearch(
                composition.NewEmptyMainSearch().SetIndex("my-index"))))).SetInjectedItems(
            []composition.InjectionInjectedItem{
              *composition.NewEmptyInjectionInjectedItem().SetKey("my-unique-injected-item-key").SetSource(composition.InjectedItemSearchSourceAsInjectedItemSource(
                composition.NewEmptyInjectedItemSearchSource().SetSearch(
                  composition.NewEmptyInjectedItemSearch().SetIndex("my-index")))).SetPosition(0).SetLength(3),
            }).
            SetDeduplication(
              composition.NewEmptyDeduplication().SetPositioning(composition.DedupPositioning("highestInjected")))))))))
if err != nil {
  // handle the eventual error
  panic(err)
}


// print the response
print(response)

// Initialize the client
CompositionClient client = new CompositionClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

// Call the API
TaskIDResponse response = client.putCompositionRule(
  "compositionID",
  "rule-with-deduplication",
  new CompositionRule()
    .setObjectID("rule-with-deduplication")
    .setDescription("my description")
    .setEnabled(true)
    .setConditions(Arrays.asList(new Condition().setAnchoring(Anchoring.CONTAINS).setPattern("harry")))
    .setConsequence(
      new CompositionRuleConsequence().setBehavior(
        new CompositionInjectionBehavior().setInjection(
          new Injection()
            .setMain(new InjectionMain().setSource(new InjectionMainSearchSource().setSearch(new MainSearch().setIndex("my-index"))))
            .setInjectedItems(
              Arrays.asList(
                new InjectionInjectedItem()
                  .setKey("my-unique-injected-item-key")
                  .setSource(new InjectedItemSearchSource().setSearch(new InjectedItemSearch().setIndex("my-index")))
                  .setPosition(0)
                  .setLength(3)
              )
            )
            .setDeduplication(new Deduplication().setPositioning(DedupPositioning.HIGHEST_INJECTED))
        )
      )
    )
);

// print the response
System.out.println(response);

// Initialize the client
const client = compositionClient('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// Call the API
const response = await client.putCompositionRule({
  compositionID: 'compositionID',
  objectID: 'rule-with-deduplication',
  compositionRule: {
    objectID: 'rule-with-deduplication',
    description: 'my description',
    enabled: true,
    conditions: [{ anchoring: 'contains', pattern: 'harry' }],
    consequence: {
      behavior: {
        injection: {
          main: { source: { search: { index: 'my-index' } } },
          injectedItems: [
            { key: 'my-unique-injected-item-key', source: { search: { index: 'my-index' } }, position: 0, length: 3 },
          ],
          deduplication: { positioning: 'highestInjected' },
        },
      },
    },
  },
});


// print the response
console.log(response);

// Initialize the client
val client = CompositionClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

// Call the API
var response =
  client.putCompositionRule(
    compositionID = "compositionID",
    objectID = "rule-with-deduplication",
    compositionRule =
      CompositionRule(
        objectID = "rule-with-deduplication",
        description = "my description",
        enabled = true,
        conditions =
          listOf(
            Condition(
              anchoring = Anchoring.entries.first { it.value == "contains" },
              pattern = "harry",
            )
          ),
        consequence =
          CompositionRuleConsequence(
            behavior =
              CompositionInjectionBehavior(
                injection =
                  Injection(
                    main =
                      InjectionMain(
                        source =
                          InjectionMainSearchSource(search = MainSearch(index = "my-index"))
                      ),
                    injectedItems =
                      listOf(
                        InjectionInjectedItem(
                          key = "my-unique-injected-item-key",
                          source =
                            InjectedItemSearchSource(
                              search = InjectedItemSearch(index = "my-index")
                            ),
                          position = 0,
                          length = 3,
                        )
                      ),
                    deduplication =
                      Deduplication(
                        positioning =
                          DedupPositioning.entries.first { it.value == "highestInjected" }
                      ),
                  )
              )
          ),
      ),
  )


// print the response
println(response)

// Initialize the client
$client = CompositionClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// Call the API
$response = $client->putCompositionRule(
    'compositionID',
    'rule-with-deduplication',
    ['objectID' => 'rule-with-deduplication',
        'description' => 'my description',
        'enabled' => true,
        'conditions' => [
            ['anchoring' => 'contains',
                'pattern' => 'harry',
            ],
        ],
        'consequence' => ['behavior' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'my-index',
        ],
        ],
        ],
            'injectedItems' => [
                ['key' => 'my-unique-injected-item-key',
                    'source' => ['search' => ['index' => 'my-index',
                    ],
                    ],
                    'position' => 0,
                    'length' => 3,
                ],
            ],
            'deduplication' => ['positioning' => 'highestInjected',
            ],
        ],
        ],
        ],
    ],
);


// print the response
var_dump($response);

# Initialize the client
# In an asynchronous context, you can use CompositionClient instead, which exposes the exact same methods.
client = CompositionClientSync("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Call the API
response = client.put_composition_rule(
    composition_id="compositionID",
    object_id="rule-with-deduplication",
    composition_rule={
        "objectID": "rule-with-deduplication",
        "description": "my description",
        "enabled": True,
        "conditions": [
            {
                "anchoring": "contains",
                "pattern": "harry",
            },
        ],
        "consequence": {
            "behavior": {
                "injection": {
                    "main": {
                        "source": {
                            "search": {
                                "index": "my-index",
                            },
                        },
                    },
                    "injectedItems": [
                        {
                            "key": "my-unique-injected-item-key",
                            "source": {
                                "search": {
                                    "index": "my-index",
                                },
                            },
                            "position": 0,
                            "length": 3,
                        },
                    ],
                    "deduplication": {
                        "positioning": "highestInjected",
                    },
                },
            },
        },
    },
)


# print the response
print(response)

# Initialize the client
client = Algolia::CompositionClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Call the API
response = client.put_composition_rule(
  "compositionID",
  "rule-with-deduplication",
  Algolia::Composition::CompositionRule.new(
    algolia_object_id: "rule-with-deduplication",
    description: "my description",
    enabled: true,
    conditions: [Algolia::Composition::Condition.new(anchoring: "contains", pattern: "harry")],
    consequence: Algolia::Composition::CompositionRuleConsequence.new(
      behavior: Algolia::Composition::CompositionInjectionBehavior.new(
        injection: Algolia::Composition::Injection.new(
          main: Algolia::Composition::InjectionMain.new(
            source: Algolia::Composition::InjectionMainSearchSource.new(
              search: Algolia::Composition::MainSearch.new(index: "my-index")
            )
          ),
          injected_items: [
            Algolia::Composition::InjectionInjectedItem.new(
              key: "my-unique-injected-item-key",
              source: Algolia::Composition::InjectedItemSearchSource.new(
                search: Algolia::Composition::InjectedItemSearch.new(index: "my-index")
              ),
              position: 0,
              length: 3
            )
          ],
          deduplication: Algolia::Composition::Deduplication.new(positioning: "highestInjected")
        )
      )
    )
  )
)


# print the response
puts(response)

// Initialize the client
val client = CompositionClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

// Call the API
val response = Await.result(
  client.putCompositionRule(
    compositionID = "compositionID",
    objectID = "rule-with-deduplication",
    compositionRule = CompositionRule(
      objectID = "rule-with-deduplication",
      description = Some("my description"),
      enabled = Some(true),
      conditions = Some(
        Seq(
          Condition(
            anchoring = Some(Anchoring.withName("contains")),
            pattern = Some("harry")
          )
        )
      ),
      consequence = CompositionRuleConsequence(
        behavior = CompositionInjectionBehavior(
          injection = Injection(
            main = InjectionMain(
              source = Some(
                InjectionMainSearchSource(
                  search = MainSearch(
                    index = "my-index"
                  )
                )
              )
            ),
            injectedItems = Some(
              Seq(
                InjectionInjectedItem(
                  key = "my-unique-injected-item-key",
                  source = InjectedItemSearchSource(
                    search = InjectedItemSearch(
                      index = "my-index"
                    )
                  ),
                  position = 0,
                  length = 3
                )
              )
            ),
            deduplication = Some(
              Deduplication(
                positioning = DedupPositioning.withName("highestInjected")
              )
            )
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

// print the response
println(response)

// Initialize the client
let client = try CompositionClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")

// Call the API
let response = try await client.putCompositionRule(
    compositionID: "compositionID",
    objectID: "rule-with-deduplication",
    compositionRule: CompositionRule(
        objectID: "rule-with-deduplication",
        conditions: [CompositionCondition(pattern: "harry", anchoring: CompositionAnchoring.contains)],
        consequence: CompositionRuleConsequence(behavior: CompositionBehavior
            .compositionInjectionBehavior(CompositionInjectionBehavior(injection: Injection(
                main: InjectionMain(source: InjectionMainSource
                    .injectionMainSearchSource(
                        InjectionMainSearchSource(search: MainSearch(index: "my-index"))
                    )),
                injectedItems: [InjectionInjectedItem(
                    key: "my-unique-injected-item-key",
                    source: InjectedItemSource
                        .injectedItemSearchSource(
                            InjectedItemSearchSource(search: InjectedItemSearch(index: "my-index"))
                        ),
                    position: 0,
                    length: 3
                )],
                deduplication: Deduplication(positioning: DedupPositioning.highestInjected)
            )))),
        description: "my description",
        enabled: true
    )
)

// print the response
print(response)