In our last post we looked at Actions and ActionPlans, and one of the really funky things we can do is setting ActionPlans to trigger on a time schedule or setting ActionTriggers to trigger on an event.
We’re going to build on the examples we had on the last post, so we’ll assume your code is up to the point where we’ve added a Signup Bonus to an account, using an ActionPlan we assigned when creating the account.
In this post, we’re going to create an action that charges $6, called “Action_Monthly_Charge“, and tie it to an ActionPlan called “ActionPlan_Monthly_Charge“, but to demo how this works rather than charging this Monthly, we’re going to charge it every minute.
Then with our balances ticking down, we’ll set up an ActionTrigger to trigger when the balance drops below $95, and alert us.
Defining the Monthly Charge Action
The Action for the Monthly charge will look much like the other actions we’ve defined, except the Identifier is *debit so we know we’re deducting from the balance, and we’ll log to the CDRs table too:
# Action to add a Monthly charge of $6
Action_Monthly_Charge = {
"id": "0",
"method": "ApierV1.SetActions",
"params": [
{
"ActionsId": "Action_Monthly_Charge",
"Actions": [
{
'Identifier': '*debit',
'BalanceType': '*monetary',
'Units': 6,
'Id': 'Action_Monthly_Charge_Debit',
'Weight': 70},
{
"Identifier": "*log",
"Weight": 60,
'Id' : "Action_Monthly_Charge_Log"
},
{
"Identifier": "*cdrlog",
"BalanceId": "",
"BalanceUuid": "",
"BalanceType": "*monetary",
"Directions": "*out",
"Units": 0,
"ExpiryTime": "",
"Filter": "",
"TimingTags": "",
"DestinationIds": "",
"RatingSubject": "",
"Categories": "",
"SharedGroups": "",
"BalanceWeight": 0,
"ExtraParameters": "{\"Category\":\"^activation\",\"Destination\":\"Recurring Charge\"}",
"BalanceBlocker": "false",
"BalanceDisabled": "false",
"Weight": 80
},
]}]}
pprint.pprint(CGRateS_Obj.SendData(Action_Monthly_Charge))Next we’ll need to wrap this up into an ActionPlan, this is where some of the magic happens. Inside the action plan we can set a once off time, or a recurring time, kinda like Cron.
We’re setting the time to *every_minute so things will happen quickly while we watch, this action will get triggered every 60 seconds. In real life of course, for a Monthly charge, we’d want to trigger this Action monthly, so we’d set this value to *monthly. If we wanted this to charge on the 2nd of the month we’d set the MonthDays to “2”, etc, etc.
# # Create ActionPlan using SetActionPlan to trigger the Action_Monthly_Charge
SetActionPlan_Daily_Action_Monthly_Charge_JSON = {
"method": "ApierV1.SetActionPlan",
"params": [{
"Id": "ActionPlan_Monthly_Charge",
"ActionPlan": [{
"ActionsId": "Action_Monthly_Charge",
"Years": "*any",
"Months": "*any",
"MonthDays": "*any",
"WeekDays": "*any",
"Time": "*every_minute",
"Weight": 10
}],
"Overwrite": True,
"ReloadScheduler": True
}]
}
pprint.pprint(CGRateS_Obj.SendData(
SetActionPlan_Daily_Action_Monthly_Charge_JSON))
Alright, but now what’s going to happen?
If you think the accounts will start getting debited every 60 seconds after applying this, you’d be wrong, we need to associate this ActionPlan with an Account first, this is how we control which accounts get which ActionPlans tied to them, to do this we’ll use the SetAccout API again we’ve been using to create accounts:
# Create the Account object inside CGrateS & assign ActionPlan_Signup_Bonus and ActionPlan_Monthly_Charge
Create_Account_JSON = {
"method": "ApierV2.SetAccount",
"params": [
{
"Tenant": "cgrates.org",
"Account": str(Account),
"ActionPlanIds": ["ActionPlan_Signup_Bonus", "ActionPlan_Monthly_Charge"],
"ActionPlansOverwrite": True,
"ReloadScheduler":True
}
]
}
print(CGRateS_Obj.SendData(Create_Account_JSON))So what’s going to happen if we run this?
Well, for starters the ActionPlan named “ActionPlan_Signup_Bonus” is going to be triggered, as in the ActionPlan it’s Timing is set to *asap, so CGrateS will apply the corresponding Action (“Action_Add_Signup_Bonus“) right away, which will credit the account $99.
But a minute after that, we’ll trigger the ActionPlan named “ActionPlan_Monthly_Charge”, as the timing for this is set to *every_minute, when the Action “Action_Monthly_Charge” is triggered, it’s going to be deducting $6 from the balance.
We can check this by using the GetAccount API:
# Get Account Info
pprint.pprint(CGRateS_Obj.SendData({'method': 'ApierV2.GetAccount', 'params': [
{"Tenant": "cgrates.org", "Account": str(Account)}]}))You should see a balance of $99 to start with, and then after 60 seconds, it should be down to $93, and so on.
{'error': None,
'id': None,
'result': {'ActionTriggers': None,
'AllowNegative': False,
'BalanceMap': {'*monetary': [{'Blocker': False,
'Categories': {},
'DestinationIDs': {},
'Disabled': False,
'ExpirationDate': '2023-11-17T14:57:20.71493633+11:00',
'Factor': None,
'ID': 'Balance_Signup_Bonus',
'RatingSubject': '',
'SharedGroups': {},
'TimingIDs': {},
'Timings': None,
'Uuid': '3a896369-8107-4e32-bcef-2d078c981b8a',
'Value': 99,
'Weight': 1200}]},
'Disabled': False,
'ID': 'cgrates.org:Nick_Test_123',
'UnitCounters': None,
'UpdateTime': '2023-10-17T14:57:21.802521707+11:00'}}
Triggering Actions based on Balances with ActionTriggers
Okay, so we’ve set up recurring charges, now let’s get notified if the balance drops below $95, we’ll start, like we have before, with defining an Action, this will log to the CDRs table, HTTP post and write to syslog:
#Define a new Action to send an HTTP POST
Action_HTTP_Notify_95 = {
"id": "0",
"method": "ApierV1.SetActions",
"params": [
{
"ActionsId": "Action_HTTP_Notify_95",
"Actions": [
{
"Identifier": "*cdrlog",
"BalanceId": "",
"BalanceUuid": "",
"BalanceType": "*monetary",
"Directions": "*out",
"Units": 0,
"ExpiryTime": "",
"Filter": "",
"TimingTags": "",
"DestinationIds": "",
"RatingSubject": "",
"Categories": "",
"SharedGroups": "",
"BalanceWeight": 0,
"ExtraParameters": "{\"Category\":\"^activation\",\"Destination\":\"Balance dipped below $95\"}",
"BalanceBlocker": "false",
"BalanceDisabled": "false",
"Weight": 80
},
{
"Identifier": "*http_post_async",
"ExtraParameters": "http://10.177.2.135/95_remaining",
"ExpiryTime": "*unlimited",
"Weight": 700
},
{
"Identifier": "*log",
"Weight": 1200
}
]}]}
pprint.pprint(CGRateS_Obj.SendData(Action_HTTP_Notify_95))
Now we’ll define an ActionTrigger to check if the balance is below $95 and trigger our newly created Action (“Action_HTTP_Notify_95“) when that condition is met:
#Define ActionTrigger
ActionTrigger_95_Remaining_JSON = {
"method": "APIerSv1.SetActionTrigger",
"params": [
{
"GroupID" : "ActionTrigger_95_Remaining",
"ActionTrigger":
{
"BalanceType": "*monetary",
"Balance" : {
'BalanceType': '*monetary',
'ID' : "*default",
'BalanceID' : "*default",
'Value' : 95,
},
"ThresholdType": "*min_balance",
"ThresholdValue": 95,
"Weight": 10,
"ActionsID" : "Action_HTTP_Notify_95",
},
"Overwrite": True
}
]
}
pprint.pprint(CGRateS_Obj.SendData(ActionTrigger_95_Remaining_JSON))
We’ve defined the ThresholdType of *min_balance, but we could equally set this to ThresholdType to *max_balance, *balance_expired or trigger when a certain Counter has been triggered enough times.
Adding an ActionTrigger to an Account
Again, like the ActionPlan we created before, before the ActionTrigger we just created will be used, we need to associate it with an Account, for this we’ll use the AddAccountActionTriggers API, specify the Account and the ActionTriggerID for the ActionTrigger we just created.
#Add ActionTrigger to Account
Add_ActionTrigger_to_Account_JSON = {
"method": "APIerSv1.AddAccountActionTriggers",
"params": [
{
"Tenant": "cgrates.org",
"Account": str(Account),
"ActionTriggerIDs": ["ActionTrigger_95_Remaining"],
"ActionTriggersOverwrite": True
}
]
}
pprint.pprint(CGRateS_Obj.SendData(Add_ActionTrigger_to_Account_JSON))If we run this all together, creating the account with the “ActionPlan_Signup_Bonus” will give the account a $99 Balance. But after 60 seconds, “ActionPlan_Monthly_Charge” will kick in, and every 60 seconds after that, at which point the balance will get to below $95 when CGrateS will trigger the ActionTrigger “ActionTrigger_95_Remaining” and get the HTTP POST to the HTTP endpoint and log entry:
We can check on this using the ApierV2.GetAccount method, where we’ll see the ActionTrigger we just defined.
Checking out the LastExecutionTime we can see if the ActionTrigger been triggered or not.
So using this technique, we can notify a customer when they’ve used a certain amount of their balance, but we can lock out Accounts who have spent more than their allocated spend limit by setting an Action that suspends the Account once it reaches a certain level. We notify customers when balance expires, or if a certain number of counters has been triggered.
As always I’ve put all the code used in this example, from start to finish, up on GitHub.