Struct CreateMeterBuilder 

pub struct CreateMeterBuilder {
    pub config: CreateMeterConfig,
    /* private fields */
}

Fields

config: CreateMeterConfig

Implementations

impl CreateMeterBuilder

pub fn new( handle: Arc<Handle>, name: String, event_name: String, aggregation: MeterAggregation, measurement_unit: String, ) -> Self

pub fn name(self, name: String) -> Self

pub fn event_name(self, event_name: String) -> Self

pub fn aggregation(self, aggregation: MeterAggregation) -> Self

pub fn measurement_unit(self, measurement_unit: String) -> Self

pub fn description(self, description: String) -> Self

Examples found in repository

examples/create_meter.rs (line 32)

async fn main() {
    let bearer_token = env::var("DODO_PAYMENTS_BEARER_TOKEN")
        .expect("DODO_PAYMENTS_BEARER_TOKEN must be set in env variables");

    let client = DodoPayments::new(
        DodoPaymentsConfigBuilder::new()
            .bearer_token(&bearer_token)
            .environment("test_mode"),
    );

    // Create a simple count aggregation meter
    let aggregation = MeterAggregation {
        aggregation_type: AggregationType::Count,
        key: None,
    };

    let response = client
        .create_meter(
            "API Requests".to_string(),
            "api_request".to_string(),
            aggregation,
            "requests".to_string(),
        )
        .description("Track API requests".to_string())
        .send()
        .await;

    println!("Response: {:#?}", response);

    // Create a more complex meter with sum aggregation and a filter
    let sum_aggregation = MeterAggregation {
        aggregation_type: AggregationType::Sum,
        key: Some("amount".to_string()),
    };

    // Note: For complex filters, you would need to construct the JSON structure manually
    // This is a simplified example showing the basic structure
    let filter_json = serde_json::json!({
        "conjunction": "and",
        "clauses": [
            {
                "key": "user_type",
                "operator": "equals",
                "value": "premium"
            }
        ]
    });

    let filter = MeterFilter {
        conjunction: Conjunction::And,
        clauses: vec![filter_json],
    };

    let response2 = client
        .create_meter(
            "Premium Revenue".to_string(),
            "payment_processed".to_string(),
            sum_aggregation,
            "usd_cents".to_string(),
        )
        .description("Track revenue from premium users".to_string())
        .filter(filter)
        .send()
        .await;

    println!("Response 2: {:#?}", response2);
}

pub fn filter(self, filter: MeterFilter) -> Self

Examples found in repository

examples/create_meter.rs (line 70)

async fn main() {
    let bearer_token = env::var("DODO_PAYMENTS_BEARER_TOKEN")
        .expect("DODO_PAYMENTS_BEARER_TOKEN must be set in env variables");

    let client = DodoPayments::new(
        DodoPaymentsConfigBuilder::new()
            .bearer_token(&bearer_token)
            .environment("test_mode"),
    );

    // Create a simple count aggregation meter
    let aggregation = MeterAggregation {
        aggregation_type: AggregationType::Count,
        key: None,
    };

    let response = client
        .create_meter(
            "API Requests".to_string(),
            "api_request".to_string(),
            aggregation,
            "requests".to_string(),
        )
        .description("Track API requests".to_string())
        .send()
        .await;

    println!("Response: {:#?}", response);

    // Create a more complex meter with sum aggregation and a filter
    let sum_aggregation = MeterAggregation {
        aggregation_type: AggregationType::Sum,
        key: Some("amount".to_string()),
    };

    // Note: For complex filters, you would need to construct the JSON structure manually
    // This is a simplified example showing the basic structure
    let filter_json = serde_json::json!({
        "conjunction": "and",
        "clauses": [
            {
                "key": "user_type",
                "operator": "equals",
                "value": "premium"
            }
        ]
    });

    let filter = MeterFilter {
        conjunction: Conjunction::And,
        clauses: vec![filter_json],
    };

    let response2 = client
        .create_meter(
            "Premium Revenue".to_string(),
            "payment_processed".to_string(),
            sum_aggregation,
            "usd_cents".to_string(),
        )
        .description("Track revenue from premium users".to_string())
        .filter(filter)
        .send()
        .await;

    println!("Response 2: {:#?}", response2);
}

pub async fn send(self) -> Result<CreateMeterResponse, Error>

Examples found in repository

examples/create_meter.rs (line 33)

async fn main() {
    let bearer_token = env::var("DODO_PAYMENTS_BEARER_TOKEN")
        .expect("DODO_PAYMENTS_BEARER_TOKEN must be set in env variables");

    let client = DodoPayments::new(
        DodoPaymentsConfigBuilder::new()
            .bearer_token(&bearer_token)
            .environment("test_mode"),
    );

    // Create a simple count aggregation meter
    let aggregation = MeterAggregation {
        aggregation_type: AggregationType::Count,
        key: None,
    };

    let response = client
        .create_meter(
            "API Requests".to_string(),
            "api_request".to_string(),
            aggregation,
            "requests".to_string(),
        )
        .description("Track API requests".to_string())
        .send()
        .await;

    println!("Response: {:#?}", response);

    // Create a more complex meter with sum aggregation and a filter
    let sum_aggregation = MeterAggregation {
        aggregation_type: AggregationType::Sum,
        key: Some("amount".to_string()),
    };

    // Note: For complex filters, you would need to construct the JSON structure manually
    // This is a simplified example showing the basic structure
    let filter_json = serde_json::json!({
        "conjunction": "and",
        "clauses": [
            {
                "key": "user_type",
                "operator": "equals",
                "value": "premium"
            }
        ]
    });

    let filter = MeterFilter {
        conjunction: Conjunction::And,
        clauses: vec![filter_json],
    };

    let response2 = client
        .create_meter(
            "Premium Revenue".to_string(),
            "payment_processed".to_string(),
            sum_aggregation,
            "usd_cents".to_string(),
        )
        .description("Track revenue from premium users".to_string())
        .filter(filter)
        .send()
        .await;

    println!("Response 2: {:#?}", response2);
}