User-Restricted Access to Data

1
2
3
4
5
index.set_settings(
  attributesForFaceting: [
    'filterOnly(visible_by)'
  ]
)

1
2
3
4
5
index.setSettings({
  attributesForFaceting: [
    'filterOnly(visible_by)'
  ]
});

1
2
3
4
5
index.set_settings({
    'attributesForFaceting': [
        'filterOnly(visible_by)'
    ]
})

1
2
3
4
5
6
7
IndexSettings settings = new IndexSettings
  {
      AttributesForFaceting = new List<string>
      {
          "filterOnly(visible_by)"
      }
  };

1
2
index.setSettings(new IndexSettings()
        .setAttributesForFaceting(Collections.singletonList("visible_by")));

1
2
3
res, err := index.SetSettings(search.Settings{
  AttributesForFaceting: opt.AttributesForFaceting("filterOnly(visible_by)"),
})

1
2
3
4
5
6
7
client.execute {
  changeSettings of "your_index_name" `with` IndexSettings(
    attributesForFaceting = Some(Seq(
      "filterOnly(visible_by)",
    ))
  )
}

1
2
3
4
5
6
7
val settings = settings {
    attributesForFaceting {
        +FilterOnly("visible_by")
    }
}

index.setSettings(settings)

1
2
3
4
index.partial_update_object({
  visible_by: ['Angela', 'group/Finance', 'group/Shareholders'],
  objectID: 'myID1'
})

1
2
3
4
index.partialUpdateObject({
  visible_by: ['Angela', 'group/Finance', 'group/Shareholders' ],
  objectID: 'myID1'
});

1
index.partial_update_object({'objectID': 'myID1', 'visible_by': ['Angela', 'group/Finance', 'group/Shareholders']})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Post
{
  [JsonProperty(PropertyName = "objectID")]
  public string ObjectId { get; set; }

  [JsonProperty("visible_by")]
  public List<int> ViewableBy { get; set; }
}

List<Post> posts = new List<Post>
{
    new Post { ObjectID = "myID1", ViewableBy = new List<String> { "Angela", "group/Finance", "group/Shareholders" } },
};

index.PartialUpdateObjects(posts);

1
2
3
4
5
6
7
8
class DemoClass {
  // getters setters omitted
  @JsonProperty("visible_by")
  private List<String> viewableBy;
}

index.partialUpdateObject(new DemoClass()
        .setViewableBy(Arrays.aslist("Angela", "group/Finance", "group/Shareholders")));

1
2
3
4
res, err := index.PartialUpdateObject(map[string]interface{}{
  "visible_by": []string{"Angela", "group/Finance", "group/Shareholders" },
  "objectID":    "myID1",
})

1
2
3
4
5
client.execute {
  partialUpdate from "index" objects Seq(
    Post("myID1", Some(Seq("Angela", "group/Finance", "group/Shareholders")))
  )
}

1
2
3
4
5
6
7
8
9
10
11
index.partialUpdateObject(
    ObjectID("myID1"),
    Partial.Update(
        Attribute("visible_by"),
        jsonArray {
            +("Angela" as String)
            +("group/Finance" as String)
            +("group/Shareholders" as String)
        }
    )
)

1
2
3
4
5
6
7
current_user_id = 'Angela'
current_group_id = 'Board'

secured_api_key = Algolia::Search::Client.generate_secured_api_key(
  'YourSearchOnlyAPIKey', # A search key that you keep private
  { filters: 'visible_by:' + current_user_id + ' OR visible_by:group/' + current_group_id + ' OR visible_by:group/Everybody' }
)

1
2
3
4
5
6
7
8
9
10
11
// Only in Node.js

const currentUserID = 'Angela';
const currentGroupID = 'Board';

const publicKey = client.generateSecuredApiKey(
  'YourSearchOnlyAPIKey', // A search key that you keep private
  {
    filters: `visible_by:${currentUserID} OR visible_by:group/${currentGroupID} OR visible_by:group/Everybody`
  }
);

1
2
3
4
5
6
7
8
9
10
from algoliasearch.search_client import SearchClient

current_user_id = 'Angela'
current_group_id = 'Board'

public_key = SearchClient.generate_secured_api_key(
    'YourSearchOnlyAPIKey', { # A search key that you keep private
      'filters': 'visible_by:' + current_user_id + ' OR visible_by:group/' + current_group_id + ' OR visible_by:group/Everybody'
    }
)

1
2
3
4
5
6
7
8
9
10
int currentUserId = "Angela";
int currentGroupId = "Board";

SecuredApiKeyRestriction restriction = new SecuredApiKeyRestriction
  {
      Query = new Query { Filters = $"visible_by:{currentUserId} OR visible_by:group/{currentGroupId} OR visible_by:group/Everybody" },
  };

// A search key that you keep private
client.GenerateSecuredApiKeys("YourSearchOnlyAPIKey", restriction);

1
2
3
4
5
6
7
8
9
10
11
int currentUserID = "Angela";
int currentGroupID = "Board";

SecuredApiKeyRestriction restriction =
    new SecuredApiKeyRestriction()
        .setQuery(new Query().setFilters(String.format("visible_by:%s OR visible_by:group/%s OR visible_by:group/Everybody", currentUserID, currentGroupID)));

String publicKey = client.generateSecuredAPIKey(
    "YourSearchOnlyAPIKey", // A search key that you keep private
    restriction
);

1
2
3
4
5
6
7
8
currentUserID := "Angela"
currentGroupID := "Board"
filter := fmt.Sprintf("visible_by:%s OR visible_by:group/%s OR visible_by:group/Everybody", currentUserID, currentGroupID)

key, err := search.GenerateSecuredAPIKey(
  "YourYourSearchOnlyAPIKey", // A search key that you keep private
  opt.Filters(filter),
)

1
2
3
4
5
6
7
val currentUserID: String = "Angela"
val currentGroupID: String = "Board"

val publicKey = client.generateSecuredApiKey(
  "YourSearchOnlyAPIKey", // A search key that you keep private
  Query(filters = Some("visible_by:%s OR visible_by:group/%s OR visible_by:group/Everybody".format(currentUserID, currentGroupID)))
)

1
2
3
4
5
6
val currentUserId = "Angela"
val currentGroupId = "Board"
val restriction = SecuredAPIKeyRestriction(Query(filters = "visible_by:$currentUserId OR visible_by:group/$currentGroupId OR visible_by:group/Everybody"))

// A search key that you keep private
ClientSearch.generateAPIKey(APIKey("YourSearchOnlyAPIKey"), restriction)

1
2
3
4
5
index.set_settings({
  unretrievableAttributes: [
    'visible_by'
  ]
})

1
2
3
4
5
6
7
index.setSettings({
  unretrievableAttributes: [
    'visible_by'
  ]
}).then(() => {
  // done
});

1
2
3
4
5
index.set_settings({
    'unretrievableAttributes': [
        'visible_by'
    ]
})

1
2
3
4
5
index.setSettings([
  "unretrievableAttributes": [
    "visible_by"
  ]
])

1
2
3
4
5
6
IndexSettings settings = new IndexSettings
{
  UnretrievableAttributes = new List<string> { "visible_by" }
};

index.SetSettings(settings);

1
2
3
4
5
index.setSettings(
        new IndexSettings().setUnretrievableAttributes(Collections.singletonList(
                "visible_by"
        ))
);

1
2
3
4
5
res, err := index.SetSettings(search.Settings{
  UnretrievableAttributes: opt.UnretrievableAttributes(
    "visible_by",
  ),
})

1
2
3
4
5
6
7
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    unretrievableAttributes = Some(Seq(
      "visible_by"
    ))
  )
}

1
2
3
4
5
6
7
val settings = settings {
    unretrieveableAttributes {
        +"visible_by"
    }
}

index.setSettings(settings)