Glip Compliance Exports

var SDK = require('ringcentral')
var fs = require('fs')
var https = require('https');

var rcsdk = new RC( {server: "server_url", appKey: "client_id", appSecret: "client_secret"} );
var platform = rcsdk.platform();

platform.login( {username: "username", password: "password", extension: "extension_number"} )
    .then(function(resp) {
        create_glip_compliance_export_task()
    });
}

function create_glip_compliance_export_task(){
    console.log("Create export task.")
    var endpoint = "/restapi/v1.0/glip/data-export"
    var params = {
        timeFrom: "2019-08-01T00:00:00.000Z",
        timeTo: "2019-08-26T23:59:59.999Z"
      }
    platform.post(endpoint, params)
      .then(function(resp){
          var json = resp.json()
          get_glip_compliance_export_task(json.id)
      })
      .catch(function(e){
          console.log(e)
      })
}

function get_glip_compliance_export_task(taskId){
    console.log("Check export task status ...")
    var endpoint = "/restapi/v1.0/glip/data-export/" + taskId
    platform.get(endpoint)
      .then(function(resp){
          var json = resp.json()
          if (json.status == "Completed"){
              for (var i=0; i<json.result.length; i++){
                var fileName = "glip-export-reports/" + json.creationTime + "_" + i + ".zip"
                get_glip_report_archived_content(json.datasets[i].uri, fileName)
              }
          }else if (json.status == "Accepted" || json.status == "InProgress") {
              setTimeout(function(){
                get_glip_compliance_export_task(taskId)
              }, 5000);
          }else
              console.log(json.status)
      })
      .catch(function(e){
          console.log(e)
      })
}

function get_glip_report_archived_content(contentUri, fileName){
    var uri = platform.createUrl(contentUri, {addToken: true});
    download(uri, fileName, function(){
        console.log("Save report zip file to the local machine.")
    })
}

const download = function(uri, dest, cb) {
    var file = fs.createWriteStream(dest);
    var request = https.get(uri, function(response) {
        response.pipe(file);
        file.on('finish', function() {
            file.close(cb);
        });
    });
}

from ringcentral import SDK
import time, urllib2

sdk = SDK( "client_id", "client_secret", "server_url" )
platform = sdk.platform()
platform.login( "username", "extension", "password" )

def create_glip_compliance_export_task():
    print ("Create export task.")
    endpoint = "/restapi/v1.0/glip/data-export"
    params = {
        "timeFrom": "2019-07-01T00:00:00.000Z",
        "timeTo": "2019-07-29T23:59:59.999Z"
      }
    resp = platform.post(endpoint, params)
    json = resp.json()
    get_glip_compliance_export_task(json.id)

def get_glip_compliance_export_task(taskId):
    print("Check export task status ...")
    endpoint = "/restapi/v1.0/glip/data-export/" + taskId
    response = platform.get(endpoint)
    jsonObj = response.json()
    if jsonObj.status == "Completed":
        length = len(jsonObj.datasets)
        for i in range(length):
            fileName = "glip-export-reports_" + jsonObj.creationTime + "_" + str(i) + ".zip"
            get_glip_report_archived_content(jsonObj.datasets[i].uri, fileName)
    elif jsonObj.status == "Accepted" || jsonObj.status == "InProgress":
        time.sleep(5)
        get_glip_compliance_export_task(taskId)
    else:
        print (jsonObj.status)

def get_glip_report_archived_content(contentUri, zipFile):
    print("Save export zip file to the local machine.")
    uri = platform.create_url(contentUri, False, None, True);
    fileHandler = urllib2.urlopen(uri)
    with open(zipFile, 'wb') as output:
        output.write(fileHandler.read())

create_glip_compliance_export_task()

<?php
require('vendor/autoload.php');

$rcsdk = new RingCentral\SDK\SDK( "client_id", "client_secret", "server_url" );

$platform = $rcsdk->platform();
$platform->login( "username", "extension_number", "password" );

create_glip_compliance_export_task();

function create_glip_compliance_export_task(){
    global $platform;
    echo ("Create export task.\n");
    $endpoint = "/restapi/v1.0/glip/data-export";
    try {
        $response = $platform->post($endpoint,
            array(
                'timeFrom' => "2019-08-01T00:00:00.000Z",
                'timeTo' => "2019-08-26T23:59:59.999Z",
            ));
        $json = $response->json();
        get_glip_compliance_export_task($json->id);
    }catch(\RingCentral\SDK\Http\ApiException $e) {
        echo($e);
    }
}

function get_glip_compliance_export_task($taskId){
    global $platform;
    echo ("Check export task status ...\n");
    $endpoint = "/restapi/v1.0/glip/data-export/" . $taskId;
    try {
        $response = $platform->get($endpoint);
        $json = $response->json();
        if ($json->status == "Completed"){
            for ($i=0; $i<count($json->datasets); $i++){
              $fileName = "glip-export-reports_" . $json->creationTime . "_" . $i . ".zip";
              get_glip_report_archived_content($json->datasets[$i]->uri, $fileName);
            }
        }else if ($json->status == "Accepted" || $json->status == "InProgress"){
            sleep(5);
            get_glip_compliance_export_task($taskId);
        }else
          echo ($json->status);
    }catch(\RingCentral\SDK\Http\ApiException $e) {
        echo($e);
    }
}

function get_glip_report_archived_content($contentUri, $fileName){
    global $platform;
    echo ("Save export zip file to the local machine.\n");
    $uri = $platform->createUrl($contentUri, array(
        'addServer' => false,
        'addMethod' => 'GET',
        'addToken'  => true
    ));
    file_put_contents($fileName, fopen($uri, 'r'));
}

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

namespace Export_Glip_Data
{
    class Program
    {
        static RestClient rcsdk;
        static void Main(string[] args)
        {
            rcsdk = new RestClient("client_id", "client_secret", "server_url");
            await rcsdk.Authorize("username", "extension_number", "password");
            create_glip_compliance_export_task().Wait();
        }
        static private async Task create_glip_compliance_export_task()
        {
            var parameters = new CreateDataExportTaskRequest();
            parameters.timeFrom = "2019-08-01T00:00:00.000Z";
            parameters.timeTo = "2019-08-26T23:59:59.999Z";

            var resp = await rcsdk.Restapi().Glip().DataExport().Post(parameters);
            Console.WriteLine("Create export task");
            var taskId = resp.id;
            Boolean polling = true;
            while (polling)
            {
                Console.WriteLine("Check export task status ...");
                Thread.Sleep(5000);
                resp = await rcsdk.Restapi().Glip().DataExport(taskId).Get();
                if (resp.status != "InProgress")
                {
                    polling = false;
                }
            }
            if (resp.status == "Completed")
            {
                for (var i = 0; i < resp.datasets.Length; i++)
                {
                    var fileName = "glip-export-reports_" + resp.creationTime + "_" + i + ".zip";
                    var contentUrl = resp.datasets[i].uri + "?access_token=" + rcsdk.token.access_token;
                    WebClient webClient = new WebClient();
                    webClient.DownloadFile(contentUrl, fileName);
                    Console.WriteLine("Save report zip file to the local machine.");
                }
            }
            else
            {
                Console.WriteLine("Error!");
            }
        }
    }
}

import com.ringcentral.*;
import com.ringcentral.definitions.*;
import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;

public class Export_Glip_Data {
    static RestClient rcsdk;
    public static void main(String[] args) {
        var obj = new Export_Glip_Data();
        rcsdk = new RestClient("client_id", "client_secret", "server_url");
        try {
            rcsdk.authorize("username", "extension_number", "password");
            obj.create_glip_compliance_export_task();
        } catch (RestException | IOException e) {
            e.printStackTrace();
        }
    }
    public void create_glip_compliance_export_task() throws RestException, IOException {
        var parameters = new CreateDataExportTaskRequest();
        parameters.timeFrom = "2019-08-01T00:00:00.000Z";
        parameters.timeTo = "2019-08-26T23:59:59.999Z";

        var resp = rcsdk.restapi().glip().dataexport().post(parameters);
        System.out.println("Create export task.");
        var taskId = resp.id;
        boolean polling = true;
        while (polling)
        {
            System.out.println("Check export task status ...");
            try {
                Thread.sleep(5000);
                resp = rcsdk.restapi().glip().dataexport(taskId).get();
                if (!resp.status.equals("InProgress"))
                  polling = false;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if (resp.status.equals("Completed")) {
            for (var i = 0; i < resp.datasets.length; i++)
            {
                var fileName = "./src/test/resources/glip-export-reports_" + resp.creationTime + "_" + i + ".zip";
                var contentUrl = resp.datasets[i].uri + "?access_token=" + rcsdk.token.access_token;
                try (BufferedInputStream inputStream = new BufferedInputStream(new URL(contentUrl).openStream());
                    FileOutputStream fileOS = new FileOutputStream(fileName)) {
                    byte data[] = new byte[1024];
                    int byteContent;
                    while ((byteContent = inputStream.read(data, 0, 1024)) != -1) {
                        fileOS.write(data, 0, byteContent);
                    }
                    System.out.println("Save report zip file to the local machine.");
                } catch (IOException e) {
                   // handles IO exceptions
                    System.out.println("Error!");
                }
            }
        }
    }
}

require 'ringcentral'
require "open-uri"

$rc = RingCentral.new( 'client_id', 'client_secret', 'server_url')
$rc.authorize( username:  'username', extension: 'extension_number', password:  'password')

def create_glip_compliance_export_task()
    puts "Create export task."
    endpoint = "/restapi/v1.0/glip/data-export"
    response = $rc.post(endpoint, payload: {
        timeFrom: "2019-07-01T00:00:00.000Z",
        timeTo: "2019-07-29T23:59:59.999Z"
      })
    get_glip_compliance_export_task(response.body['id'])
end

def get_glip_compliance_export_task(taskId)
    puts "Check export task status ..."
    endpoint = "/restapi/v1.0/glip/data-export/" + taskId
    response = $rc.get(endpoint)
    body = response.body
    if body['status'] == "Completed"
        length = body['datasets'].length
        for i in (0...length)
            fileName = "glip-export-reports_" + body['creationTime'] + "_" + i.to_s + ".zip"
            get_glip_report_archived_content(body['datasets'][i]['uri'], fileName)
        end
    elsif body['status'] == "Accepted" || body['status'] == "InProgress"
        sleep(5)
        get_glip_compliance_export_task(taskId)
    else
        puts body['status']
    end
end

def get_glip_report_archived_content(contentUri, zipFile)
    puts "Save report zip file to the local machine."
    uri = contentUri + "?access_token=" + $rc.token['access_token']
    open(uri) do |data|
      File.open(zipFile, "wb") do |file|
        file.write(data.read)
      end
    end
end

create_glip_compliance_export_task()