Struct Context 

pub struct Context(/* private fields */);

the Context object for an authorization request

Implementations

impl Context

pub fn empty() -> Self

Create an empty Context

let context = Context::empty();

pub fn from_pairs( pairs: impl IntoIterator<Item = (String, RestrictedExpression)>, ) -> Result<Self, ContextCreationError>

Create a Context from a map of key to “restricted expression”, or a Vec of (key, restricted expression) pairs, or any other iterator of (key, restricted expression) pairs.

let context = Context::from_pairs([
  ("key".to_string(), RestrictedExpression::from_str(r#""value""#).unwrap()),
  ("age".to_string(), RestrictedExpression::from_str("18").unwrap()),
]).unwrap();

pub fn get(&self, key: &str) -> Option<EvalResult>

Retrieves a value from the Context by its key.

Arguments

• key - The key to look up in the context

Returns

• Some(EvalResult) - If the key exists in the context, returns its value
• None - If the key doesn’t exist or if the context is not a Value type

Examples

let context = Context::from_json_str(r#"{"rayId": "abc123"}"#, None).unwrap();
if let Some(value) = context.get("rayId") {
    // value here is an EvalResult, convertible from the internal Value type
    println!("Found value: {:?}", value);
}
assert_eq!(context.get("nonexistent"), None);

pub fn from_json_str( json: &str, schema: Option<(&Schema, &EntityUid)>, ) -> Result<Self, ContextJsonError>

Create a Context from a string containing JSON (which must be a JSON object, not any other JSON type, or you will get an error here). JSON here must use the __entity and __extn escapes for entity references, extension values, etc.

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer). Since different Actions have different schemas for Context, you also must specify the Action for schema-based parsing.

let json_data = r#"{
    "sub": "1234",
    "groups": {
        "1234": {
            "group_id": "abcd",
            "group_name": "test-group"
        }
    }
}"#;
let context = Context::from_json_str(json_data, None).unwrap();

pub fn from_json_value( json: Value, schema: Option<(&Schema, &EntityUid)>, ) -> Result<Self, ContextJsonError>

Create a Context from a serde_json::Value (which must be a JSON object, not any other JSON type, or you will get an error here). JSON here must use the __entity and __extn escapes for entity references, extension values, etc.

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer). Since different Actions have different schemas for Context, you also must specify the Action for schema-based parsing.

let schema_json = serde_json::json!(
    {
      "": {
        "entityTypes": {
          "User": {},
          "Album": {},
        },
        "actions": {
          "view": {
             "appliesTo": {
               "principalTypes": ["User"],
               "resourceTypes": ["Album"],
               "context": {
                 "type": "Record",
                 "attributes": {
                   "sub": { "type": "Long" }
                 }
               }
             }
          }
        }
      }
    });
let schema = Schema::from_json_value(schema_json).unwrap();

let a_eid = EntityId::from_str("view").unwrap();
let a_name: EntityTypeName = EntityTypeName::from_str("Action").unwrap();
let action = EntityUid::from_type_name_and_id(a_name, a_eid);
let data = serde_json::json!({
    "sub": 1234
});
let context = Context::from_json_value(data, Some((&schema, &action))).unwrap();

pub fn from_json_file( json: impl Read, schema: Option<(&Schema, &EntityUid)>, ) -> Result<Self, ContextJsonError>

Create a Context from a JSON file. The JSON file must contain a JSON object, not any other JSON type, or you will get an error here. JSON here must use the __entity and __extn escapes for entity references, extension values, etc.

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer). Since different Actions have different schemas for Context, you also must specify the Action for schema-based parsing.

let mut json = File::open("json_file.json").unwrap();
let context = Context::from_json_file(&json, None).unwrap();

pub fn merge( self, other_context: impl IntoIterator<Item = (String, RestrictedExpression)>, ) -> Result<Self, ContextCreationError>

Merge this Context with another context (or iterator over (String, RestrictedExpression) pairs), returning an error if the two contain overlapping keys

pub fn validate( &self, schema: &Schema, action: &EntityUid, ) -> Result<(), RequestValidationError>

Validates this context against the provided schema

Returns Ok(()) if the context is valid according to the schema, or an error otherwise

This validation is already handled by Request::new, so there is no need to separately call if you are validating the whole request

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Context

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Context

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl IntoIterator for Context

type Item = (String, RestrictedExpression)

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl RefCast for Context

type From = Context

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self