User Answering Rules

const RC = require('@ringcentral/sdk').SDK
require('dotenv').config();

var rcsdk = new RC({
    'server':       process.env.RC_SERVER_URL,
    'clientId':     process.env.RC_APP_CLIENT_ID,
    'clientSecret': process.env.RC_APP_CLIENT_SECRET
});
var platform = rcsdk.platform();
platform.login({ 'jwt':  process.env.RC_USER_JWT })

platform.on(platform.events.loginSuccess, () => {
  create_user_custom_rule()
});

async function create_user_custom_rule() {
  var params = {
    enabled: true,
    type: "Custom",
    name: "My weekly meetings",
    schedule: {
      weeklyRanges: {
        monday: [{ from: "09:00", to: "10:00" }],
        friday: [{ from: "10:00", to: "15:00" }]
      }
    },
    callHandlingAction: "TakeMessagesOnly"
  }
  try {
    var resp = await platform.post('/restapi/v1.0/account/~/extension/~/answering-rule', params)
    var jsonObj = await resp.json()
    console.log(jsonObj)
  } catch (e) {
    console.log(e.message)
  }
}

#!/usr/bin/python

# You get the environment parameters from your
# application dashbord in your developer account
# https://developers.ringcentral.com

import os
import sys

from dotenv import load_dotenv
from ringcentral import SDK
load_dotenv()

rcsdk = SDK( os.environ.get('RC_APP_CLIENT_ID'),
             os.environ.get('RC_APP_CLIENT_SECRET'),
             os.environ.get('RC_SERVER_URL') )
platform = rcsdk.platform()
try:
  platform.login( jwt=os.environ.get('RC_USER_JWT') )

except Exception as e:
  sys.exit("Unable to authenticate to platform: " + str(e))

params = {
    'enabled': True,
    'type': 'Custom',
    'name': "My weekly meetings",
    'schedule' : {
      'weeklyRanges': {
        'monday': [{ 'from': "09:00",'to': "10:00" }],
        'friday': [{ 'from': "10:00", 'to': "15:00" }]
      }
    },
    'callHandlingAction': "TakeMessagesOnly"
  }
resp = platform.post('/restapi/v1.0/account/~/extension/~/answering-rule', params)

print(resp.text())

<?php
// Remember to modify the path ./../ pointing to the location where the RingCentral SDK was installed and the .env file was saved!
require('./../vendor/autoload.php');
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__ . './../');
$dotenv->load();

$rcsdk = new RingCentral\SDK\SDK( $_ENV['RC_APP_CLIENT_ID'],
                                  $_ENV['RC_APP_CLIENT_SECRET'],
                                  $_ENV['RC_SERVER_URL'] );
$platform = $rcsdk->platform();
$platform->login( [ "jwt" => $_ENV['RC_USER_JWT'] ] );

$params = array (
    'enabled' => true,
    'type' => "Custom",
    'name' => "My weekly meetings",
    'schedule' => array (
      'weeklyRanges' => array (
        'monday' => array ( array ('from' => "09:00", 'to' => "10:00")),
        'friday' => array ( array ('from' => "10:00", 'to' => "15:00"))
      )
    ),
    'callHandlingAction' => "TakeMessagesOnly"
);
$resp = $platform->post('/account/~/extension/~/answering-rule', $params);

print_r ($resp->text());
?>

using System;
using System.Threading.Tasks;
using RingCentral;

namespace UserCustomAnsweringRule
{
  class Program {
    static RestClient restClient;
    static async Task Main(string[] args)
    {
      restClient = new RestClient(
        Environment.GetEnvironmentVariable("RC_APP_CLIENT_ID"),
        Environment.GetEnvironmentVariable("RC_APP_CLIENT_SECRET"),
        Environment.GetEnvironmentVariable("RC_SERVER_URL"));

      await restClient.Authorize(Environment.GetEnvironmentVariable("RC_USER_JWT"));
      await create_user_custom_answering_rule();
    }
    static private async Task create_user_custom_answering_rule()
    {
      var parameters = new CreateAnsweringRuleRequest();
      parameters.enabled = true;
      parameters.type = "Custom";
      parameters.name = "My weekly meetings";
      var schedule = new ScheduleInfo();
      var weeklyRanges = new WeeklyScheduleInfo();
      TimeInterval meetingTime = new TimeInterval();
      meetingTime.from = "09:00";
      meetingTime.to = "10:00";
      weeklyRanges.monday = new TimeInterval[] { meetingTime };

      meetingTime = new TimeInterval();
      meetingTime.from = "10:00";
      meetingTime.to = "15:00";
      weeklyRanges.friday = new TimeInterval[] { meetingTime };

      schedule.weeklyRanges = weeklyRanges;
      parameters.schedule = schedule;
      parameters.callHandlingAction = "TakeMessagesOnly";

      var response = await restClient.Restapi().Account().Extension().AnsweringRule().Post(parameters);
      var jsonStr = JsonConvert.SerializeObject(response);
      Console.WriteLine(jsonStr);
    }
  }
}

package com.ringcentral;

import com.ringcentral.*;
import com.ringcentral.definitions.*;
import java.io.IOException;

public class CreateCustomUserAnsweringRule {
    static RestClient rc;

    public static void main(String[] args) {
        var obj = new CreateCustomUserAnsweringRule();
    rc = new RestClient( System.getenv("RC_APP_CLIENT_ID"),
                 System.getenv("RC_APP_CLIENT_SECRET"),
                 System.getenv("RC_SERVER_URL") );
    try {
        rc.authorize( System.getenv("RC_USER_JWT") );
        obj.create_user_custom_answering_rule();
    } catch (RestException | IOException e) {
        e.printStackTrace();
    }
    }

    public void create_user_custom_answering_rule() throws RestException, IOException {
    var schedule = new ScheduleInfo();
    var weeklyRanges = new WeeklyScheduleInfo();
    TimeInterval meetingTime = new TimeInterval();
    meetingTime.from = "09:00";
    meetingTime.to = "10:00";
    weeklyRanges.monday = new TimeInterval[] { meetingTime };

    meetingTime = new TimeInterval();
    meetingTime.from = "10:00";
    meetingTime.to = "15:00";
    weeklyRanges.friday = new TimeInterval[] { meetingTime };

    schedule.weeklyRanges = weeklyRanges;

    var parameters                = new CreateAnsweringRuleRequest();
    parameters.enabled            = true;
    parameters.type               = "Custom";
    parameters.name               = "My weekly meetings";
    parameters.schedule           = schedule;
    parameters.callHandlingAction = "TakeMessagesOnly";

    CustomAnsweringRuleInfo response =  rc.restapi().account().extension().answeringRule().post(parameters);
    System.out.println("Rule created: " + response.id);

    }
}

#!usr/bin/ruby

# You get the environment parameters from your
# application dashbord in your developer account
# https://developers.ringcentral.com

require 'ringcentral'
require 'dotenv/load'

$rc = RingCentral.new(ENV['RC_APP_CLIENT_ID'],
                      ENV['RC_APP_CLIENT_SECRET'],
                      ENV['RC_SERVER_URL'])

$rc.authorize(jwt: ENV['RC_USER_JWT'])

params = {
    enabled: true,
    type: 'Custom',
    name: 'My weekly meetings',
    schedule: {
      weeklyRanges: {
        monday: [{ from: "09:00", to: "10:00" }],
        friday: [{ from: "10:00", to: "15:00" }]
      }
    },
    callHandlingAction: "TakeMessagesOnly",
}
resp = $rc.post('/restapi/v1.0/account/~/extension/~/answering-rule', payload: params)

puts resp.body