Zoho Analytics
访问 ZOHO ANALYTICS
定价 联系我们
找到想要查找的内容了吗？是 | 否
NAV
CURL C# GO JAVA PHP PYTHON

Zoho Analytics API

Zoho Analytics API 提供了许多功能以帮助开发人员根据其业务应用需求构建和管理功能强大的报告和分析功能。您可以为您的产品/应用程序添加强大的商业智能功能、构建附加组件以分析来自您使用的第三方业务应用程序（例如，Google Ad-words、Google Analytics、CRM 系统等）的数据等等。实际上，许多 Zoho 应用程序（Zoho CRM、Zoho Creator、Zoho Projects 和 Zoho Books…）使用 Zoho Analytics API 以向用户无缝提供基于 Zoho Analytics 的报告和分析功能。

我们提供了易于使用的编程语言包装器（称为“客户端库”），可以方便地在您熟悉的编程语言（例如，Java、C＃、Python、PHP、GO 和 Google Applications）中使用 Zoho Analytics API。

先决条件

  1. 在所有 API 请求（而不是 HTTP 请求）中，必须使用 HTTPS。HTTP 不受支持

  2. 始终将 https://analyticsapi.zoho.com 用作 API 请求 URL。

以下是使用 Zoho Analytics API 的先决条件。

Note:

Zoho Analytics 用户帐户

用户应该具有有效 Zoho 登录电子邮件地址以使用此 API。如果您没有此地址，请注册 Zoho Analytics 并创建登录。

身份验证令牌

示例响应：


The following is a sample response for a Auth Token request.

#

#Wed Jun 29 03:07:33 PST 2013

AUTHTOKEN=************

RESULT=TRUE

响应详细信息：

* #-COMMENT  Auth Token generated date.
* AUTHTOKEN  The permanent Auth Token (Alpha numeric value) generated for
             Zoho Analytics API access.
* RESULT     Value is TRUE if the Auth Token is generated successfully.

身份验证令牌是认证用户以访问其 Zoho 帐户的唯一令牌。这是特定于用户的永久令牌，需要随每个 Zoho Analytics API 请求传递。

生成身份验证令牌

用户可使用下列其中一种方式生成身份验证令牌。您只需生成一次就可对所有 API 调用使用。

浏览器模式

要通过您的浏览器生成身份验证令牌，请遵循以下步骤：

https://accounts.zoho.com/apiauthtoken/create?SCOPE=ZohoReports/reportsapi

API 模式

要使用 API 方式生成身份验证令牌，请使用以下 URL 格式向 Zoho 帐户发送身份验证请求。

https://accounts.zoho.com/apiauthtoken/nb/create?SCOPE=ZohoReports/reportsapi&EMAIL_ID=emailId&PASSWORD=password

要随此 URL 传递的必需“POST”参数为：

参数 描述
EMAIL_ID 指定您的 Zoho 登录电子邮件地址
PASSWORD 指定您的 Zoho Analytics 密码
（Note: 如果您正在使用双重身份验证，那么必须提供特定于应用程序的密码。阅读以下注释以了解如何生成此项）

注释（适用于使用双重身份验证的用户）：

如果您已对您的 Zoho 帐户启用双重身份验证 (TFA)，那么您需要指定特定于应用程序的密码（而不是您的 Zoho Analytics 帐户密码）来生成身份验证令牌。

以下步骤用于为您的 Zoho 帐户生成特定于应用程序的密码。

  1. 登录 Zoho 帐户。
  2. 点击双重身份验证。这将打开设置页面中的双重身份验证部分。
  3. 点击管理特定于应用程序的密码按钮。
  4. 在设备（或）应用名称字段中指定描述性名称。例如，Zoho Analytics API。此设备（或）应用名称仅供参考。
  5. 指定您的 Zoho Analytics 帐户密码。
  6. 点击生成。这将生成特定于应用程序的密码。

使用此特定于应用程序的密码来为您的帐户生成身份验证令牌。点击此处以了解有关特定于应用程序的密码的更多信息。

管理身份验证令牌

您可通过“Zoho 帐户”页面访问和管理您的 Zoho 帐户的所有生效密钥身份验证令牌。

要访问生效身份验证令牌，请执行以下操作：

重要提示

报告工作空间

要使用 Zoho Analytics API，用户应该已经使用所提供的基于浏览器的 Web 界面在 Zoho Analytics 服务中创建了包含所需表和报告的报告工作空间。如果您的 Zoho Analytics 帐户中没有任何报告工作空间，那么您不能使用该 API。要了解如何创建工作空间，请点击此处。

API 规范

Zoho Analytics API 使用 HTTP 作为底层传输协议。它基于 REST 准则。以下是 REST API 的构造方式的基本点：

在引用实际 API 方法之前，必须清晰了解 API 规范。

请求格式

样本请求：


The below URL adds a row in the table.

https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?
ZOHO_ACTION=ADDROW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
authtoken=************&ZOHO_API_VERSION=1.0&Name=Gary
&Date Of Birth=12-Jun-1980&Country=USA&Salary=10000

所有 API 请求应作为 HTTPS POST 请求放置。此请求包含以下元素：

URI

URI 指向 Zoho Analytics 内要对其执行操作的资源。

https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

它包含以下部分：

要在查询字符串中传递的参数

以下代码片段显示应作为查询字符串随以上所定义 URI 传递的常规参数：

<URI>?ZOHO_ACTION=[IMPORT/EXPORT...]&ZOHO_OUTPUT_FORMAT=[XML/JSON/PDF/...]&ZOHO_ERROR_FORMAT=[XML/JSON]&authtoken=<your auth token>&ZOHO_API_VERSION=1.0

“ZOHO_ACTION”之类的控制参数是必需的，必须作为 URL 中的查询字符串的一部分发送。请参阅“常规参数”文档以了解有关可在查询字符串中传递的可能参数的更多令牌。

要通过 POST 请求主体传递的参数

除了在查询字符串中传递的参数之外，特定操作所需的其他信息（例如，“添加行”操作中的行值等等）需要作为 POST 参数传递

<param>1=<value>1&<param2>=<value2>....

参数应以 application/x-www-form-urlencoded 格式编写（这是任何简单 html 表单使用的默认格式）。

Note: 导入 csv 文件时，应使用 multipart/form-data 格式。（这是包含用于上传文件的文件类型字段的 html 表单使用的默认格式）

响应格式

样本响应：对于 ADDROW


Sample response to a request adding a row to the table.

XML 格式：

<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="ADDROW">
    <result>
        <!-- All the columns in the row , including formula columns -->
        <row>
            <column name="Name">Gary</column>
            <column name="Date Of Birth">12-Jun-1980</column>
            <column name="Basic">10000</column>
            <column name="Country">USA</column>
        </row>
    </result>
<response>

JSON 格式：

{
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName/TableName",
        "action": "ADDROW",
        "result":
        {
            "column_order":["Name","Date Of Birth","Salary","Country"],
            "rows":
            ["Gary","12-Jun-1980",10000,"USA"]
        }
    }
}

API 请求的响应格式由请求中传递的 ZOHO_OUTPUT_FORMAT 查询参数控制。目前，Zoho Analytics 支持 XML 和 JSON 响应格式。仅导出操作支持 CSV 和 PDF 响应格式。

Note: 请参阅此链接以了解 API 执行发生错误时的响应格式。

XML 格式

响应会将 <response> 标记作为根节点。它可能包含 <result> 或 <error> 节点作为子代，但不会同时包含两者。常规情况下会出现 <result> 节点，发生错误时将出现 <error> 节点。

格式

<?xml version="1.0" encoding="UTF-8" ?>

<response uri="/api/EmailAddress/WorkspaceName/TableName" action="<specifiedaction>">

<result>

[specific XML response based on action]

</result>

</response>

JSON 格式

JSON 格式与 XML 格式遵循同一模式。

格式

{

"response":

{

"uri": "/api/EmailAddress/WorkspaceName/TableName",

"action": "<specified action>",

"result": {[action specific properties]}

}

}

其他格式

仅当 ZOHO_ACTION 为 EXPORT 时，才能指定 CSV 和 PDF 之类的其他格式。这些格式没有任何通用可解析标题/脚注。请参阅此链接以了解有关这些格式的更多详细信息。

错误处理

样本错误响应：IMPORT DATA


Sample error response for import data in Table.

XML 格式：

<?xml version="1.0" encoding="UTF-8"?>
<response url="/api/EmailAddress/WorkspaceName/TableName" action="IMPORT">
    <error>
        <code>7138</code>
        <message>
        Table "TableName" is not present in the workspace "WorkspaceName"
        </message>
    </error>
</response>

JSON 格式：

{
    "response":
    {
        "url": "/api/EmailAddress/WorkspaceName/TableName",
        "action": "IMPORT",
        "error":
        {
            "code":7138,
            "message": "Table "TableName" is not present in the workspace "WorkspaceName""
        }
    }
}

API 执行可能导致错误情况。在这类情况下，您可遵循以下步骤以确定错误情况并进行处理：

XML 格式

<?xml version="1.0" encoding="UTF-8" ?>

<response uri="/api/EmailAddress/WorkspaceName/TableName" action="<specifiedaction>">

<error>

[error details]

</error>

</response>

JSON 格式

{

"response":

{

"uri": "/api/EmailAddress/WorkspaceName/TableName",

"action": "<specified action>",

"error": {[error details]}

}

}

API URL 的查询字符串中的常规参数

在本节中，我们将讨论可以在每个 API 调用的查询字符串中传递的必需参数和可选参数。

必需参数：

身份验证令牌

身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。这相当于通过浏览器登录 Zoho 服务。点击此处以了解如何生成身份验证令牌。

ZOHO_ACTION

此参数指定 API 请求要执行的操作。样本值为：

Note: ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。

ZOHO_OUTPUT_FORMAT

此参数指定响应的输出格式。以下是受支持的格式：

如果 ZOHO_ACTION 为 EXPORT，那么以下格式受支持。

ZOHO_ERROR_FORMAT

如果尝试处理请求时发生错误，请指定响应的输出格式。以下是受支持的格式：

ZOHO_API_VERSION

编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0

可选参数：

这些参数必须在 POST 请求主体中发送。

ZOHO_DATE_FORMAT

可在导入包含日期列且 Zoho Analytics 未正确标识其格式的数据时使用此参数。

示例：ZOHO_DATE_FORMAT=dd-MMM-yyyy

查看此链接以了解有关如何构造自定义日期格式的更多详细信息。

数据 API

本节列示一些 API，它们可用于在 Zoho Analytics 数据表中执行添加数据、批量导入、删除和更新操作。本节还提供一些 API 以便使用 PDF、Excel、JSON、HTML、图像和 CSV 格式导出表、报告和统计图表。

添加行

下载客户端库： C# | GO | JAVA | PHP | PYTHON



样本请求：

using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void addRow(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            Dictionary<string, string> ColumnValues = new Dictionary
                                                 <string, string>();
            ColumnValues.Add("Region", "South");
            Dictionary<string, string> addRowRes = RepClient.AddRow(tableURI,
                                    ColumnValues, config);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.addRow(rc);
        }
    }
}

package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func addrow() {
        url := reportclient.GetUri(email, dbname, tbname)
        columnvalues := map[string]string{}
        columnvalues["Id"] = "999"
        columnvalues["Name"] = "zzz"
        resultmap , err := reportclient.AddRow(url, columnvalues)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(resultmap)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        addrow()
}

import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();
    Map colval = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void addrow() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        colval.put("Id", 101);
        colval.put("Name", "sam");
        Map result = rc.addRow(uri,colval,config);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.addrow();
    }
}

<?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $column_values = array("Employee Name" => "Shankar", "Employee ID" =>
                                   "2015", "Experience" => "5");
    $response_array = $report_client_request->addRow($uri, $column_values);
?>

from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def AddRow(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        rowData = {"Date":"01 Jan, 2009 00:00:00","Region":"East","Product
                Category": "Samples","Product":"SampleProduct","Customer Name":
                "Sample", "Sales":2000,"Cost":2000}
        result = rc.addRow(uri,rowData,None)
        print result

obj = Sample()
obj.AddRow(obj.rc)

curl -d "ZOHO_ACTION=ADDROW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
        &ZOHO_API_VERSION=1.0&authtoken=************&Id=999
        &Name=Gary&Date Of Birth=12-Jun-1980&Salary=10000&Country=USA"
        https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

样本响应 JSON 格式：

{
    "response":
    {
        "url": "/api/EmailAddress/WorkspaceName/TableName",
        "action": "ADDROW",
        "result":
        {
            "column_order":["Name","Date Of Birth","Salary","Country"],
            "rows":["Gary","12-Jun-1980",10000,"USA"]
        }
    }
}

样本响应 XML 格式：

<?xml version="1.0" encoding="UTF-8" ?>
<response url ="/api/EmailAddress/WorkspaceName/TableName"action="ADDROW">
    <result>
    <!-- All the columns in the row , including formula columns -->
        <row>
            <column name="Name">Gary</column>
            <column name="Date Of Birth">12-Jun-1980</column>
            <column name="Basic">10000</column>
            <column name="Country">USA</column>
        </row>
    </result>
</response>

此 API 允许您在指定表中添加一行。

http 请求

https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=ADDROW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ColumnName1=Value1&ColumnName2=Value2&ColumnName3=Value3&ColumnName4=Value4

常规参数

参数 可能的值 描述
ZOHO_ACTION ADDROW 此参数指定 API 请求要执行的操作。
Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

特定于操作的参数（该行的数据）

该行的列值应作为 POST 参数以 <columnname>=<value> 格式传递。（这些参数应使用 application/x-www-form-urlencoded 格式）。

<columnname> - 它是指要添加值的表列的名称。

<value> - 它是指要对此列添加的对应值。

ADDROW 中的可能错误代码

7103、7138、7507、7511、8016、8504、8506、8516、8533

删除数据

下载客户端库： C# | GO | JAVA | PHP | PYTHON



样本请求：

using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void deleteRow(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            string criteria = "\"Region\"='South'";
            RepClient.DeleteData(tableURI, criteria, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.deleteRow(rc);
        }
    }
}

package main

import (
        "fmt"
        "zoho/pkg/reportclient"
)

var(
        authtoken = "************"
)

func deletedata() {
        url := reportclient.GetUri("Email Address", "Workspace Name", "Table Name")
        params := map[string]string{}
        params["ZOHO_CRITERIA"] = "Id=2"
        resp,err := reportclient.DeleteData(url, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(resp)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        deletedata()
}

import com.adventnet.zoho.client.report.*;

public class Sample
{
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void deletedata() throws Exception
    {
        String uri = rc.getURI("Email Address","Workspace Name","Table Name");
        String criteria = "No=12";
        Long result = rc.deleteData(uri,criteria,null);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.deletedata();
    }
}

<?php
    require 'ReportClient.php';

    $AUTHTOKEN = "************";

    $request = new ReportClient($AUTHTOKEN);

    $uri = $request->getURI("Email Address", "Workspace Name", "Table Name");
    $criteria = "Experience = 3";
    $resp = $request->deleteData($uri ,$criteria);
    print_r($resp);
?>

from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def DeleteData(self,rc):
        uri = rc.getURI("Email Address","Workspace Name","Table Name")
        criteria = "No=1001" 
        result = rc.deleteData(uri,criteria,None);
        print result

obj = Sample()
obj.DeleteData(obj.rc)

curl -d "ZOHO_ACTION=DELETE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_CRITERIA=("Department" = 'Finance')"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

样本响应 JSON 格式：

{
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName/TableName",
        "action": "DELETE",
        "criteria": "\"Department\" = \'Finance\'",
        "result":
        {
            "message": "Deleted rows",
            "deletedrows":"4"
        }
    }
}

样本响应 XML 格式：

<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="DELETE">
    <criteria>"Department" = 'Finance'</criteria>
    <result>
        <message>Deleted rows</message>
        <deletedrows>4</deletedrows>
    </result>
</response>

可使用此 API 删除表中的数据。

http 请求

https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=DELETE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_CRITERIA=("ColumnName1"='CriteriaValue1' and "ColumnName2"='CriteriaValue2')

常规参数

参数 可能的值 描述
ZOHO_ACTION DELETE 此参数指定 API 请求要执行的操作。
Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

特定于操作的参数

参数 可能的值 描述
ZOHO_CRITERIA
（可选）		 条件 如果未发送该参数，那么所有行会被删除。如果发送该条件，那么只会删除符合该条件的行。有关 ZOHO_CRITERIA 的格式的更多详细信息，请查看此链接。
ZOHO_VALID_JSON true / false 默认情况下，它将为 false。
True - 返回有效 JSON 数据（带有 JSON 转义）
False - 返回 JSON 数据（带有 JS 转义）。

DELETE DATA 中的可能错误代码

7103、7138、8002、8004、8504、8506、8516、8533

更新数据

下载客户端库： C# | GO | JAVA | PHP | PYTHON



样本请求：

using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void updateRow(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            Dictionary<string, string> ColumnValues = new Dictionary
                                                <string, string>();
            ColumnValues.Add("Region", "North");
            string criteria = "\"Region\"='South'";
            RepClient.UpdateData(tableURI, ColumnValues, criteria, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.updateRow(rc);
        }
    }
}

package main

import (
        "fmt"
        "zoho/pkg/reportclient"
)

var(
        authtoken = "************"
)

func updatedata() {
        url := reportclient.GetUri("Email Address", "Workspace Name", "Table Name")
        params := map[string]string{}
        params["Salary"] = "100"
        params["ZOHO_CRITERIA"] = "Id=1"
        resp,err := reportclient.UpdateData(url, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(resp)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        updatedata()
}

import com.adventnet.zoho.client.report.*;

public class Sample
{
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void updatedata() throws Exception
    {
        String uri = rc.getURI("Email Address","Workspace Name","Table Name");
        Map colval = new HashMap();
        colval.put("Salary", 1000);
        String criteria = "Age=55";
        Long result = rc.updateData(uri,colval,criteria,null);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.updatedata();
    }
}

<?php
    require 'ReportClient.php';

    $AUTHTOKEN = "************";

    $request = new ReportClient($AUTHTOKEN);

    $uri = $request->getURI("Email Address", "Workspace Name", "Table Name");
    $column_values = array("Salary" => "10000");
    $criteria = "Experience = 2";
    $resp = $request->updateData($uri ,$column_values, $criteria);
    print_r($resp);
?>

from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    AUTHTOKEN="************"

    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def updateData(self,rc):
        uri = rc.getURI("Email Address","Workspace Name","Table Name")
        updateInfo = {"Region":"West","Product":"SampleProduct_2"}
        criteria = "No=1000"
        result = rc.updateData(uri,updateInfo,criteria,None)
        print result

obj = Sample()
obj.updateData(obj.rc)

curl -d "ZOHO_ACTION=UPDATE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************&Name=as
         &ZOHO_CRITERIA=("Department" = 'Finance')"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

样本响应 JSON 格式：

{
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName/TableName",
        "action": "UPDATE",
        "criteria": "\"Department\" = 'Finance'",
        "result":
        {
            "updatedColumns":["Salary","Deduction","Perks"],
            "updatedRows":"4"
        }
    }
}

样本响应 XML 格式：

<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="UPDATE">
    <criteria>"Department" = 'Finance'</criteria>
    <result>
        <updatedColumns>
            <column>Salary</column>
            <column>Deduction</column>
            <column>Perks</column>
        </updatedColumns>
        <updatedRows>4</updatedRows>
    </result>
</response>

可使用此 API 更新表中的数据。

http 请求

https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=UPDATE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ColumnName1=Value1&ColumnName2=Value2&ZOHO_CRITERIA=("ColumnName1"='CriteriaValue1')

常规参数

参数 可能的值 描述
ZOHO_ACTION UPDATE 此参数指定 API 请求要执行的操作。
Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

特定于操作的参数

参数 可能的值 描述
ZOHO_CRITERIA
（可选）		 条件 如果未发送该参数，那么所有行会被更新。如果发送该条件，那么只会更新符合该条件的行。有关该条件的格式的更多详细信息，请查看此链接。
ZOHO_VALID_JSON true / false 默认情况下，它将为 false。
True - 返回有效 JSON 数据（带有 JSON 转义）
False - 返回 JSON 数据（带有 JS 转义）。

指定要更新的数据（POST 参数）

以 <columnname>=<value> 格式传递您要更新其值的列。（这些参数应使用 application/x-www-form-urlencoded 格式）。

<columnname> - 它是指要更新其值的表列的名称。

<value> - 它是指要在该列中更新的对应值

要指定空 (null) 值，在发送该参数时应带上空值。在以上示例中，Deduction 值设置为空。

UPDATE DATA 中的可能错误代码

7103、7138、7507、8002、8004、8016、8504、8506、8516、8533

导入数据

下载客户端库： C# | GO | JAVA | PHP | PYTHON



样本请求：

using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void importData(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            Dictionary<string, string> ImportConfig = new Dictionary
                                                 <string, string>();
            ImportConfig.Add("ZOHO_ON_IMPORT_ERROR", "ABORT");
            ImportConfig.Add("ZOHO_CREATE_TABLE", "TRUE");
            ImportConfig.Add("ZOHO_AUTO_IDENTIFY", "TRUE");
            Dictionary<string, string> ImportRes = RepClient.ImportData(
                 tableURI, ZohoReportsConstants.APPEND, "C:\\workspace\\mydata.csv", ImportConfig);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.importData(rc);
        }
    }
}

package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func importdata() {
        url := reportclient.GetUri(email, dbname, tbname)
        params := map[string]string{}
        file := "/home/sample.csv"
        importtype := "APPEND"
        autoidentity := "true"
        onerror := "ABORT"
        resp , err := reportclient.ImportData(url, file, importtype, 
                              autoidentity, onerror, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(resp.ImportErrors)
                fmt.Println(resp.ColumnDetails)
                fmt.Println(resp.ImportType)
                fmt.Println(resp.Warnings)
                fmt.Println(resp.SelectedColumnCount)
                fmt.Println(resp.SuccessRowCount)
                fmt.Println(resp.ImportOperation)
                fmt.Println(resp.TotalColumnCount)
                fmt.Println(resp.TotalRowCount)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        importdata()
}

import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();
    File csvFile = new File("samples/StoreSales.csv");

    private ReportClient rc = new ReportClient(authtoken);

    public void importdata() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        config.put("ZOHO_AUTO_IDENTIFY","true");
        config.put("ZOHO_ON_IMPORT_ERROR","ABORT");
        config.put("ZOHO_CREATE_TABLE","false");
        Object result = rc.importData(uri,"APPEND",csvFile,config,false);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.importdata();
    }
}

<?php
    require 'ReportClient.php';

    $EMAIL_ID = "abc@zoho.com";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $import_type = "APPEND";
    $file = 'files/Sample.csv';
    $auto_identify = "TRUE";
    $on_error = "ABORT";
    $response_obj = $report_client->importData($table_uri, $import_type, $file,
                        $auto_identify, $on_error);
?>

from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="abc@zoho.com"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def importData(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        try:
            with open('StoreSales.csv', 'r') as f:
            importContent = f.read()
        except Exception,e:
            print "Error Check if file StoreSales.csv exists in
                                        the current directory"
            print "(" + str(e) + ")"
            return
        impResult = rc.importData(uri,"APPEND",importContent,None)
        print "Added Rows :" +str(impResult.successRowCount) + " and Columns :"
                    + str(impResult.selectedColCount)

obj = Sample()
obj.importData(obj.rc)

curl -XPOST 
     'https://analyticsapi.zoho.com/api/UserEmail/WorkspacName/TableName?
     ZOHO_ACTION=IMPORT&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
     ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_IMPORT_TYPE=APPEND&
     ZOHO_AUTO_IDENTIFY=TRUE&ZOHO_ON_IMPORT_ERROR=ABORT&ZOHO_CREATE_TABLE=true' 
     -H 'content-type: multipart/form-data' 
     -F 'ZOHO_FILE=@/home/local/import.csv'

样本响应 JSON 格式：

{
    " response":
    {
        "uri": "/api/EmailAddress/WorkspaceName/TableName",
        "action": "IMPORT",
        "result":
        {
            "importSummary":
            {
                "totalColumnCount":3,
                "selectedColumnCount":3,
                "totalRowCount":50,
                "successRowCount":48,
                "warnings":0,
                "importOperation": "created",
                "importType": "APPEND"
            },
            "columnDetails":
            {
                "Name": "Plain Text",
                "Date Of Birth": "Date",
                "Salary": "Number"
            },
            "importErrors": "[Line: 5 Field: 3] a1213 -WARNING: Invalid
             Number value"
        }
    }
}

样本响应 XML 格式：

<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="IMPORT">
    <result>
        <importSummary>
            <totalColumnCount>3 </totalColumnCount>
            <selectedColumnCount>3</selectedColumnCount>
            <totalRowCount>50</totalRowCount>
            <successRowCount>48</successRowCount>
            <warnings>0</warnings>
            <importOperation>created</importOperation>
            <importType>APPEND</importType>
        </importSummary>
        <columnDetails>
            <column datatype="Plain Text">Name </column>
            <column datatype="Date">Date Of Birth</column>
            <column datatype="Number">Salary</column>
        </columnDetails>
        <!-- The first 100 errors are alone sent -->
        <importErrors>
            [Line: 5 Field: 3] a1213 -WARNING: Invalid Number value
        </importErrors>
    </result>
</response>

通过 Zoho Analytics API，您可以批量添加/更新数据。要添加/更新的数据应为 CSV 或 JSON 文件格式。

http 请求

https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=IMPORT&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_IMPORT_TYPE=APPEND&ZOHO_AUTO_IDENTIFY=TRUE&ZOHO_ON_IMPORT_ERROR=ABORT&ZOHO_CREATE_TABLE=TRUE&ZOHO_FILE=SampleFiles/Test.csv

常规参数

参数 可能的值 描述
ZOHO_ACTION IMPORT 此参数指定 API 请求要执行的操作。
Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

特定于操作的参数

参数 可能的值 描述
ZOHO_CRITERIA
（可选）		 条件 如果未发送该参数，那么所有行会被更新。如果已发送条件，那么与该条件相匹配的行将更新。
ZOHO_FILE 或
ZOHO_IMPORT_DATA
（必需）		 文件或字符串 ZOHO_FILE - 要导入的文件。
ZOHO_IMPORT_DATA - 要导入的字符串。
ZOHO_IMPORT_FILETYPE
（可选）		 CSV/JSON 默认值为 CSV。要导入的文件的格式。受支持的格式包括：
  • CSV
  • JSON
    		•
    ZOHO_IMPORT_TYPE
    （必需）    		 APPEND/TRUNCATEADD/UPDATEADD
  • APPEND - 将数据附加至表。
  • TRUNCATEADD - 删除表中全部现有行并将所导入数据添加为新条目。
  • UPDATEADD - 所提及列值匹配时更新该行，否则添加新条目。
    		•
    ZOHO_AUTO_IDENTIFY
    （必需）    		 TRUE/FALSE 用于指定是否自动标识 CSV 格式。
    ZOHO_ON_IMPORT_ERROR
    （必需）    		 ABORT/SKIPROW/SETCOLUMNEMPTY 此参数控制导入期间发生错误时要执行的操作。
  • ABORT - 发生任何错误时，中止整个导入。
  • SKIPROW - 发生任何错误时，跳过存在问题的特定行，然后继续导入余下部分。
  • SETCOLUMNEMPTY - 发生任何错误时，将对应该行的错误列的值设置为空，然后继续导入。
    		•
    ZOHO_CREATE_TABLE
    （可选）    		 true/false。 默认值为 false。
  • 如果为 true，那么 URL 中引用的表在所指定工作空间中不存在时将创建该表。
  • 如果为 false，那么即使 URL 中引用的表在所指定工作空间中不存在时也不会创建任何表。
    		•
    ZOHO_SELECTED_COLUMNS
    （可选）    		 列名的逗号分隔列表。
    E.g.,: Name, Department    		 指定要从上传数据导入至 Zoho Analytics 表的列。
    Note: 对于 JSON 文件，您需要指定列名以捕获完整 JSON 树型结构，例如，employee.Name, employee.Department
    ZOHO_MATCHING_COLUMNS
    （仅当 ZOHO_IMPORT_TYPE 为 UPDATEADD 时必需）    		 列名的逗号分隔列表。
    E.g.,: Name,Department    		 要匹配的列中的值将用于比较，以检查要导入的数据行是否与表中的现有行匹配。
    表中匹配的现有行将更新为所导入数据中的值。余下行将作为新行附加至该表。
    ZOHO_SKIPTOP
    （可选）    		 <number> 在要导入的 CSV 文件中从头开始跳过的行数。
    ZOHO_THOUSAND_SEPARATOR
    （可选）    		 0 / 1 / 2 / 3 默认值为 0。
    此参数控制数据中有千位分隔符时要执行的操作。
    0 - 逗号
    1 - 点
    2 - 空格
    3 - 单引号
    ZOHO_DECIMAL_SEPARATOR
    （可选）    		 0 / 1 默认值为 0。
    此参数控制数据中有小数分隔符时要执行的操作。
    0 - 点
    1 - 逗号
    ZOHO_DATE_FORMAT
    （可选）    		 日期格式。
    E.g. dd-MMM-YYYY    		 日期值的格式。如果 Zoho Analytics 无法识别要导入的任何日期字段及其格式，请指定此项。
    ZOHO_IMPORT_JSON_RETCOLNAMES
    （可选）    		 true/false。 默认值为 false。
    此参数仅在导入 JSON 文件时适用。它定义如何通过 JSON 文件构造列名。
  • 如果设置为 true，那么仅最终键属性被视为列名。
  • 如果设置为 false，那么将通过附加所有父属性（列名之间用点 (.) 分隔）来构建列名。这样生成的列名将捕获完整 JSON 树型结构 eg.， employee.Name, employee.Department
    		•

    CSV 格式详细信息

    如果 ZOHO_AUTO_IDENTIFY 设置为 false，那么需要指定这些参数。

    参数 可能的值 描述
    ZOHO_COMMENTCHAR <character> 注释字符。如果在行的开头发现所述字符，那么该 CSV 行将被跳过。
    ZOHO_DELIMITER 0 / 1 / 2 / 3 此分隔符用于在文件中分隔多个值。
    0 - 分隔符为逗号
    1 - 分隔符为制表符
    2 - 分隔符为分号
    3 - 分隔符为空格
    ZOHO_QUOTED 0 / 1 / 2 文本限定符。
    0 - 无
    1 - 单引号
    2 - 双引号

    IMPORT DATA 中的可能错误代码

    7103、7138、8002、8004、8504、8506、8516、8533

    导出数据

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public object export(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            Dictionary<string, object> resObj = RepClient.
                            ExportDataAsDictionary(tableURI, "\"Region\"
                            ='West'", null);
            Object[] columns = (Object[])resObj["column_order"];
            Object[] rows = (Object[])resObj["rows"];
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.export(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func exportdata() {
        url := reportclient.GetUri(email, dbname, tbname)
        outputformat := "pdf"
        filename := "sample"
        params := map[string]string{}
        err := reportclient.ExportData(url, filename, outputformat, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        exportdata()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    File csvFile = new File("samples/StoreSales.csv");

    private ReportClient rc = new ReportClient(authtoken);

    public void exportdata() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        rc.exportData(uri,"CSV",csvFile,null,null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.exportdata();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $output_format = "CSV";
    $criteria = "Salary = 5000";
    $report_client_response = $report_client_request->exportData($uri,
                                    $output_format);
    $file = "dummy/".$TABLE_NAME.".".$output_format;
    file_put_contents($file, $report_client_response, FILE_APPEND);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Employee"
    TABLENAME="Employee"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def exportdata(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        fileobj = open("/home/sample.csv","rw+")
        rc.exportData(uri,"CSV",fileobj)
        fileobj.close()

obj = Sample()
obj.exportdata(obj.rc)

    curl -d "ZOHO_ACTION=EXPORT&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName/TableName",
        "action": "EXPORT",
        "result":
        {
            "column_order":["Name","Department","Date Of Birth"],
            "rows":
            [
                ["John","Finance","12 May 1972"],
                ["Joan","Admin","15 June 1975"]
            ]
        }
    }
}

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="EXPORT">
    <result>
        <rows>
            <row>
                <column name="Name">Gary</column>
                <column name="Date Of Birth">12-Jun-1980</column>
                <column name="Basic">10000</column>
                <column name="Country">USA</column>
            </row>
            <row>
                <column name="Name">John</column>
                <column name="Date Of Birth">12-Jun-1981</column>
                <column name="Basic">10000</column>
                <column name="Country">Canada</column>
            </row>
            <row>
                <column name="Name">Joan</column>
                <column name="Date Of Birth">12-Jun-1982</column>
                <column name="Basic">10000</column>
                <column name="Country">Mexico</column>
            </row>
        </rows>
    </result>
</response>

    通过使用此 API，用户可以不同格式从表或报告（数据透视表、图表等等）导出/提取数据。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=EXPORT&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION EXPORT 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON/CSV/PDF/HTML/IMAGE 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数 可能的值 描述
    ZOHO_CRITERIA
    （可选）    		 条件 如果未发送该参数，那么所有行会被导出。如果发送该条件，那么只会导出符合该条件的行。有关该条件的格式的更多详细信息，请参阅此链接。
    GENERATETOC
    （可选 - 仅适用于仪表板）    		 true / false true - 生成目录。默认情况下为 false。
    ZOHO_DASHBOARD_LAYOUT
    （可选 - 仅适用于仪表板）    		 0 或 1 0 - 每个报告展示在新页面中
    1 - 布局与仪表板中一样

    其他可选参数。

    下面定义的所有参数都是可选参数。

    CSV 格式

    参数 可能的值 描述
    ZOHO_DELIMITER 0 到 3 之间的值
    0 - 逗号
    1 - 制表符
    2 - 分号
    3 - 空格    		 分隔符，用于分隔 CSV 行中的字段。
    ZOHO_RECORD_DELIMITER 0 到 2 之间的值
    0 - DOS
    1 - UNIX
    2 - MAC    		 要使用的记录分隔符（换行符）。
    ZOHO_QUOTED 0 到 1 之间的值
    0 - 单引号
    1 - 双引号    		 用于引用值的引号字符。
    ZOHO_INCLUDE_HEADER true / false true - 所导出 CSV 的第一行中包含列名。
    false - 所导出 CSV 的第一行中不包含列名。
    ZOHO_SHOW_HIDDENCOLS true / false 控制表/报告中隐藏的列必须导出至的位置。
    true - 在所导出数据中包含表/报告的隐藏列。
    false - 在所导出数据中不包含表/报告的隐藏列。

    XML 格式

    参数 可能的值 描述
    ZOHO_SHOW_HIDDENCOLS true / false 控制表/报告中隐藏的列必须导出至的位置。
    true - 在所导出数据中包含表/报告的隐藏列。
    false - 在所导出数据中不包含表/报告的隐藏列。

    HTML 格式

    参数 可能的值 描述
    ZOHO_SHOW_HIDDENCOLS true / false 控制表/报告中隐藏的列必须导出至的位置。
    true - 在所导出数据中包含表/报告的隐藏列。
    false - 在所导出数据中不包含表/报告的隐藏列。

    PDF 格式

    参数 可能的值 描述
    ZOHO_PAPERSIZE 0 到 5 之间的值
    0 - LETTER
    1 - LEGAL
    2 - TABLOID
    3 - A3
    4 - A4
    5 - AUTO    		 纸张大小。
    ZOHO_SHOW_TITLE 0 到 2 之间的值
    0 - 位于顶部
    1 - 位于底部
    2 - 无    		 控制标题位置
    ZOHO_SHOW_DESC 0 到 2 之间的值
    0 - 位于顶部
    1 - 位于底部
    2 - 无    		 控制描述位置。
    ZOHO_EXPORT_LANGUAGE 0 到 4 之间的值
    0 - 英语
    1 - 欧盟语言
    2 - 中文
    3 - 日语
    4 - 韩语
    默认 - 英语    		 PDF 将使用所指定语言呈示
    ZOHO_PAPERSTYLE 纵向/横向
    ZOHO_SHOW_HIDDENCOLS true / false 控制表/报告中隐藏的列必须导出至的位置。
    true- 在所导出数据中包含表/报告的隐藏列
    false - 在所导出数据中不包含表/报告的隐藏列。
    ZOHO_SELECTED_COLUMNS 列名的逗号分隔列表 控制需要导出的列名。如果未给出，那么将导出表/报告中的所有列。
    边距设置：
    ZOHO_TOPMARGIN
    ZOHO_BOTTOMMARGIN
    ZOHO_LEFTMARGIN
    ZOHO_RIGHTMARGIN    		 0 到 1 之间的小数值 边缘的边距（以英寸计）。可为 0 到 1 之间的小数值（例如，0.5）。
    页眉/页脚设置：
    ZOHO_HEAD_LEFT
    ZOHO_HEAD_RIGHT
    ZOHO_HEAD_CENTER
    ZOHO_FOOT_LEFT
    ZOHO_FOOT_RIGHT
    ZOHO_FOOT_CENTER    		 0 到 5 之间的值
    0 - 留为空白
    1 - 包含标题
    2 - 当前日期/时间
    3 - 以“第 # 页”的格式添加页码
    4 - 以“第 # 页，共 # 页”的格式添加页码
    5 - 自定义 - 在页脚中添加自定义文本    		 需要在特定位置对每页生成的页眉/页脚值。
    自定义页眉/页脚值
    ZOHO_HEAD_LEFT_TEXT
    ZOHO_HEAD_RIGHT_TEXT
    ZOHO_HEAD_CENTER_TEXT
    ZOHO_FOOT_LEFT_TEXT
    ZOHO_FOOT_RIGHT_TEXT
    ZOHO_FOOT_CENTER_TEXT    		 自定义文本。 如果任意页眉/页脚设置为 5（即，自定义），那么应传递对应自定义值/文本。

    图像格式

    参数 可能的值 描述
    ZOHO_WIDTH <number> 图像宽度。
    ZOHO_HEIGHT <number> 图像高度。
    ZOHO_TITLE true / false 控制是否将报告标题添加至图像。
    true - 包含标题。
    false - 不包含标题。
    ZOHO_DESCRIPTION true/false 控制是否将报告描述添加至图像。
    true - 包含描述。
    false - 不包含描述。
    ZOHO_SHOWLEGEND true / false 控制是否在所生成图像中包含图注。
    true - 在图像中包含图注。
    false - 在图像中不包含图注。
    ZOHO_IMAGE_FORMAT png / jpg 所导出图像的格式。可为 PNG 或 JPG 格式。

    JSON 格式

    参数 可能的值 描述
    ZOHO_VALID_JSON true / false 默认情况下，它将为 false。
    True - 返回有效 JSON 数据（带有 JSON 转义）
    False - 返回 JSON 数据（带有 JS 转义）。
    ZOHO_SHOW_HIDDENCOLS true / false 控制表/报告中隐藏的列必须导出至的位置。
    true - 在所导出数据中包含表/报告的隐藏列。
    false - 在所导出数据中不包含表/报告的隐藏列。
    ZOHO_CALLBACK_FUNCTION json 回调函数的名称 在页面上的 JavaScript 代码中的其他位置处理 JSON 响应

    示例：JSON 回调。

    1. 定义回调函数。

    <script>
function sampleFunction(resp)
{
    var response = resp.response;
    var result = response.result;
    var rows = result.rows;
    for(i=0;i<rows.length;i++)
    {
        var row = rows[i];
        console.log(row);
        // your application code
    }
    // your application code
}
</script>

    2.调用 api 请求并指定输出格式 JSON 和 ZOHO_CALLBACK_FUNCTION=sampleFunction。

    <script src="
https://analyticsapi.zoho.com/api/<EmailAddress>/<Workspace>/<Table>
?ZOHO_ACTION=EXPORT&ZOHO_OUTPUT_FORMAT=JSON&ZOHO_ERROR_FORMAT=XML&authtoken=
<your auth token>&ZOHO_API_VERSION=1.0&ZOHO_CALLBACK_FUNCTION=sampleFunction">
</script>

    加载页面时，将按以下形式返回响应：

    {
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName/TableName",
        "action": "EXPORT",
        "result":
        {
            "column_order":["Name","Department","Date Of Birth"],
            "rows":
            [
                ["John","Finance","12 May 1972"],
                ["Joan","Admin","15 June 1975"]
            ]
        }
    }
}

    JSON 回调 - JSONP：

    Zoho Analytics API 支持使用回调函数以异步方式处理 API 响应。如果选择 JSON 作为输出格式，那么这在“导出 API”调用中是受支持的。

    指定 JSON 作为输出格式的“导出 API”方法调用支持使用附加参数 ZOHO_CALLBACK_FUNCTION 来启用回调。通过使用回调函数，开发者可在 <script> 标记内调用“导出 API”请求，并在页面上的 JavaScript 代码中的其他位置使用 CALLBACK 函数处理 JSON 响应。

    使用 SQL 导出：

    Zoho Analytics 以 HTTP Web API 扩展的形式实现了 Zoho CloudSQL 技术。通过使用 Zoho Analytics HTTP API，用户可通过提供 SQL 查询来查询工作空间。

    有关如何使用 SQL SELECT 查询从 Zoho Analytics 获取数据的更多详细信息，请参阅有关 Zoho Analytics CloudSQL 的文档。

    EXPORT DATA 中的可能错误代码

    7103、7138、8002、8004、8504、8506、8516、8533

    应用过滤条件

    示例

    
(( "Department"='Finance' and "Salary" < 9000) or ("Department"='Admin'
     and "Salary" < 8000))

    示例

    
A sample delete request that deletes all the rows that match
the criteria "s2">"Department"='Finance'
is given below.

    URL：

    
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?
ZOHO_ACTION=DELETE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&authtoken=************&ZOHO_API_VERSION=1.0

    以 POST 参数形式发送的数据。

    
ZOHO_CRITERIA=("Department"='Finance')

ZOHO_CRITERIA is encoded for the url format. Unencoded value is provided below.
ZOHO_CRITERIA=("Department"='Finance')

    Zoho Analytics API 允许您在执行各种操作时应用过滤条件。应用条件时，仅对与所给定过滤条件相匹配的数据执行操作。

    可在以下 API 操作中应用条件：

    过滤条件必须以参数 ZOHO_CRITERIA 的形式传递至操作请求。它应该包含在 POST 请求主体中。

    格式

    在请求中传递的过滤条件应遵循 SQL SELECT WHERE 子句的格式。下面给出简单条件的通用格式：

    (<columnname/SQL expression/SQL function calls> <relational operator> <value/column name/SQL expression/SQL function calls>)

    描述

    该条件遵循类似 SQL SELECT WHERE 条件的格式。您也可在条件中使用 SQL 内置函数。这些内置函数应该是受以下任何数据库支持的函数：Oracle、MS SQL Server、MySQL、DB2、Sybase、ANSI SQL、Informix 和 PostgreSQL。

    名称 描述
    列名 它是指表或查询表中您要对其应用条件的列的名称。
    SQL 表达式 您可提供任意有效 SQL 表达式。
    以上表达式从“Sales”列值减去“Cost”列值。您可在 SQL SELECT WHERE 子句中使用任意受支持算术运算符。受支持的
    算术运算符：
    +、-、* 和 /
    SQL 函数调用 Oracle、MS SQL Server、MySQL、DB2、Sybase、ANSI SQL、Informix 和 PostgreSQL 数据库
    例如： year(date_column) = 2008。
    Note: 后续将讨论不同数据库中的所有受支持内置函数。
    关系运算符 它可以是 SQL SELECT WHERE 子句中受支持的任意关系运算符。
    受支持的关系运算符：
  • =
  • !=
  • <
  • >
  • <=
  • >=
  • LIKE
  • NOT LIKE
  • IN
  • NOT IN
  • BETWEEN
    		•
    值 它是指要匹配的确切值。
    例如：“Department” = 'Finance’
    此处 'Finance’ 是要匹配的文字值。

    条件构造注释：

    有关如何构造过滤条件更多信息，请参阅 SQL SELECT WHERE 子句文档。

    “数据 API”中的错误代码

    样本错误 XML 格式：

    
<response uri="/api/EmailAddress/WorkspaceName" action="ADDROW">
    <error>
        <code>7103</code>
        <message>
        Workspace not found! Please check whether the workspace exists
        </message>
    </error>
</response>

    样本错误 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName",
        "action": "ADDROW",
        "error":
        {
        "code":7103,
        "message": "Workspace not found! Please check whether
                               the workspace exists"
        }
    }
}

    本节列示“数据 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。

    错误代码

    错误代码 原因 解决方案
    7103 API URL 中提到的工作空间名称不存在。 检查请求 URL 中的工作空间名称，并提供有效的工作空间名称。
    7138 API 请求 URL 中指定的视图名称不存在。 检查请求 URL 中的视图名称并提供有效的视图名称。
    7507 在所提及列中输入的值未遵循所指定数据类型。 检查该列的值并按所指定数据类型提供值。
    7511 所提及列为必需列。 应对该必需列指定值。
    8002 所指定条件无效。 请提供有效条件。
    8004 条件中所提及列不在该表中。 请检查列名并提供有效名称。
    8016 对于 INSERT 或 UPDATE 操作，您需要至少一个列。 应提供至少一个带有值的列。
    8504 所需参数不正确或未发送。 请发送带有有效数据的参数。
    8506 所提及参数的已发送次数超过所需次数。 检查响应中提及的额外参数并移除。
    8516 所提及参数中传递了无效值。 对所提及参数提供有效数据。
    8533 URL 中提供的用户电子邮件地址为错误格式。 请提供有效电子邮件地址。

    如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至 support@zohoanalytics.com。Zoho Analytics 团队将回复您并给出最佳可行解决方案。

    建模 API

    本节列示所有建模 API。“建模 API”可用于添加、删除和重命名 Zoho Analytics 表中的列。它还提供了一些 API，用于将对象（工作空间、报告和公式）从一个工作空间复制到同一帐户或不同帐户中的另一个工作空间。

    复制工作空间

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void copyDatabase(IReportClient RepClient)
        {
            string dbURI = RepClient.GetURI(EMAIL, DBNAME);
            string newDBName = "newdbname";
            string newDBDesc = "dbdesc";
            bool withData = true;
            string copyDBKey = "************"
            long dbid = RepClient.CopyDatabase(dbURI, newDBName, newDBDesc,
                        withData, copyDBKey, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.copyDatabase(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
        dbkey = "************"
)

func copydatabase() {
        url := reportclient.GetDbUri(email, dbname)
        newdbname := "Sample"
        params := map[string]string{}
        newid , err := reportclient.CopyDatabase(url, newdbname, dbkey, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(newid)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        copydatabase()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void copydatabase() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        config.put("ZOHO_DATABASE_NAME", "database");
        config.put("ZOHO_COPY_DB_KEY", "************");
        long result = rc.copyDatabase(uri,config);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.copydatabase();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $db_key = "************ ";
    $db_name = "Workspace Name";
    $new_database_id = $report_client_request->copyDatabase($uri, $db_key,
                                               $db_name);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def CopyDatabase(self,rc):
        uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
        config = {"ZOHO_DATABASE_NAME":"new sales",
                      "ZOHO_COPY_DB_KEY":"************"}
        result = rc.copyDatabase(uri,config)

obj = Sample()
obj.CopyDatabase(obj.rc)

    curl -d "ZOHO_ACTION=COPYDATABASE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_DATABASE_NAME=New Workspace Name&ZOHO_COPY_DB_KEY=
         ************"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName" action="COPYDATABASE">
    <result>
        <message>
        Successfully Workspace Copied
        </message>
        <dbid>
        99999999999999
        </dbid>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress/WorkspaceName",
        "action": "COPYDATABASE",
        "result":
        {
            "message": "Successfully Workspace Copied",
            "dbid": "99999999999999"
        }
    }
}

    “复制工作空间 API”用于将工作空间从一个 Zoho Analytics 帐户复制到另一个 Zoho Analytics 帐户。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/Workspacename?ZOHO_ACTION=COPYDATABASE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_DATABASE_NAME=CopiedWorkspace&ZOHO_COPY_DB_KEY=************

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION COPYDATABASE 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_DATABASE_NAME
    （必需）    		 <Workspace name> 此参数包含目标工作空间的名称
    ZOHO_DATABASE_DESC
    （可选）    		 <Workspace description> 此参数包含目标工作空间的描述
    ZOHO_COPY_WITHDATA
    （可选）    		 true/false
  • true - 源工作空间的所有表中的数据将复制到目标工作空间。
  • false - 源工作空间的所有表中的数据不会复制到目标工作空间。
    		•
    ZOHO_COPY_DB_KEY
    （必需）    		 <Workspace key> 用于允许用户复制工作空间/报告的密钥。
    源工作空间管理员必须调用以下 URL 以获取复制工作空间密钥。
    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&authtoken=<source_db_owner_authtoken>&ZOHO_API_VERSION=1.0 .
    有关工作空间密钥的更多信息。
    Note: 您需要在以上 URL 中提供相应值，以便为您的设置生成相应的复制工作空间密钥。

    COPY WORKSPACE 中的可能错误代码

    7101、7103、7138、8024、8504、8506、8516、8533、15007

    删除工作空间

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void deleteDatabase(IReportClient RepClient)
        {
            string userURI = RepClient.GetURI(EMAIL);
            string databaseName = "Workspace Name";
            RepClient.DeleteDatabase(userURI, databaseName, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.deleteDatabase(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
)

func deletedatabase() {
        url := reportclient.GetUserUri(email)
        dbname := "Workspace Name"
        err := reportclient.DeleteDatabase(url, dbname)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        deletedatabase()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void deletedatabase() throws Exception
    {
        String uri = rc.getURI(email);
        rc.deleteDatabase(uri,"database",config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.deletedatabase();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getUserURI($EMAIL_ID);
    $db_name = "Workspace Name";
    $report_client_request->deleteDatabase($uri, $db_name);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def DeleteDatabase(self,rc):
        uri = rc.getUserURI(self.LOGINEMAILID)
        databaseName = "WorkspaceName"
        rc.deleteDatabase(uri,databaseName)

obj = Sample()
obj.DeleteDatabase(obj.rc)

    curl -d "ZOHO_ACTION=DELETEDATABASE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_DATABASE_NAME=Workspace Name"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <response uri="/api/EmailAddress" action="DELETEDATABASE">
    <result>
        <message>
        Workspace deleted successfully
        </message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "DELETEDATABASE",
        "result":
        {
            "message": "Workspace deleted successfully"
        }
    }
}

    “删除工作空间 API”用于从您的 Zoho Analytics 帐户中删除工作空间。此 API 将删除调用此 API 的用户帐户中的工作空间，而不删除其他帐户中的工作空间。请注意，如果使用此 API 删除工作空间，那么无法还原相同的工作空间。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DELETEDATABASE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_DATABASE_NAME=Workspace Name

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION DELETEDATABASE 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_DATABASE_NAME
    （必需）    		 工作空间名称 此参数包含要删除的工作空间的名称

    DELETE WORKSPACE 中的可能错误代码

    7103、7138、7165、8504、8506、8516、8533

    启用域工作空间（仅适用于白标客户）

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void enabledomaindb(IReportClient rc)
        {
            try
            {
                string uri = rc.GetURI(EMAIL);
                string dbname = "Workspace Name";
                string domainname = "Domain Name";
                var result = rc.EnableDomainDB(uri, dbname, domainname, null);
                foreach (KeyValuePair<string, string> kvp in result)
                {
                    Console.WriteLine(kvp.Key + " = " + kvp.Value);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.enabledomaindb(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"
)

var(
        authtoken = "************"
)

func EnableDomainDB(){
        url := reportclient.GetUserUri("Email Address")
        params := map[string]string{}
        err := reportclient.EnableDomainDB(url, "Workspace Name", "Domain Name", params)
        if(err != nil)
        {
            fmt.Println(err.ErrorMessage)
            fmt.Println(err.ErrorCode)
            fmt.Println(err.Action)
            fmt.Println(err.HttpStatusCode)
        } else {
            fmt.Println("success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        EnableDomainDB()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void enableDomainDB() throws Exception
    {
        String uri = rc.getURI("Email Address");
        String dbName = "Workspace Name";
        String domainName = "Domain Name";
        rc.enableDomainDB(uri, dbName, domainName, null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.enableDomainDB();
    }
}

    <?php

    require 'ReportClient.php';

    $AUTHTOKEN = "************";
    $request = new ReportClient($AUTHTOKEN);
    $uri = $request->getUserURI("Email Address");
    $dbname = "Workspace Name";
    $domain_name = "Domain Name";
    $request->enableDomainDB($uri, $dbname, $domain_name);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def enableDomainDB(self,rc):
    uri = rc.getURI("Email Address")
    dbName = "Workspace Name"
    domainName = "Domain Name"
    rc.enableDomainDB(uri,dbName,domainName)

obj = Sample()
obj.enableDomainDB(obj.rc)

    curl -d "ZOHO_ACTION=ENABLEDOMAINDB&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &DBNAME=Workspace Name&DOMAINNAME=Domain Name"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <response uri="/api/EmailAddress" action="ENABLEDOMAINDB">
    <result>
        <status>Success</status>
        <message>Domain Feature has been enabled</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "ENABLEDOMAINDB",
        "result":
        {
            "status":"Success",
            "message":"Domain Feature has been enabled"
        }
    }
}

    “启用工作空间 API”用于对白标帐户（自定义域）启用您的 Zoho Analytics 帐户中的工作空间。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=ENABLEDOMAINDB&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&DBNAME=Workspace Name&DOMAINNAME=Domain Name

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION ENABLEDOMAINDB 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    DBNAME
    （必需）    		 工作空间名称 此参数包含要启用的工作空间的名称。
    DOMAINNAME
    （必需）    		 域名 此参数包含域地址。

    ENABLE DOMAIN WORKSPACE 中的可能错误代码

    7103、7138、8023、8025、8504、8506、8516、8533

    禁用域工作空间（仅适用于白标客户）

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void disabledomaindb(IReportClient rc)
        {
            try
            {
                string uri = rc.GetURI(EMAIL);
                string dbname = "Workspace Name";
                string domainname = "Domain Name";
                var result = rc.DisableDomainDB(uri, dbname, domainname, null);
                foreach (KeyValuePair<string, string> kvp in result)
                {
                    Console.WriteLine(kvp.Key + " = " + kvp.Value);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.disabledomaindb(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"
)

var(
        authtoken = "************"
)

func DisableDomainDB(){
        url := reportclient.GetUserUri("Email Address")
        params := map[string]string{}
        err := reportclient.DisableDomainDB(url, "Workspace Name", "Domain Name", params)
        if(err != nil){
        fmt.Println(err.ErrorMessage)
        fmt.Println(err.ErrorCode)
        fmt.Println(err.Action)
        fmt.Println(err.HttpStatusCode)
        }else{
        fmt.Println("success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        DisableDomainDB()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void disableDomainDB() throws Exception
    {
        String uri = rc.getURI("Email Address");
        String dbName = "Workspace Name";
        String domainName = "Domain Name";
        rc.disableDomainDB(uri, dbName, domainName, null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.disableDomainDB();
    }
}

    <?php

    require 'ReportClient.php';

    $AUTHTOKEN = "************";
    $request = new ReportClient($AUTHTOKEN);
    $uri = $request->getUserURI("Email Address");
    $dbname = "Workspace Name";
    $domain_name = "Domain Name";
    $request->disableDomainDB($uri, $dbname, $domain_name);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def disableDomainDB(self,rc):
    uri = rc.getURI("Email Address")
    dbName = "Workspace Name"
    domainName = "Domain Name"
    rc.disableDomainDB(uri,dbName,domainName)

obj = Sample()
obj.disableDomainDB(obj.rc)

    curl -d "ZOHO_ACTION=DISABLEDOMAINDB&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &DBNAME=Workspace Name&DOMAINNAME=Domain Name"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <response uri="/api/EmailAddress" action="DISABLEDOMAINDB">
    <result>
        <status>Success</status>
        <message>Domain Feature has been disabled</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "DISABLEDOMAINDB",
        "result":
        {
            "status":"Success",
            "message":"Domain Feature has been disabled"
        }
    }
}

    “禁用工作空间 API”用于对白标帐户（自定义域）禁用您的 Zoho Analytics 帐户中的工作空间。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DISABLEDOMAINDB&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&DBNAME=Workspace Name&DOMAINNAME=Domain Name

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION DISABLEDOMAINDB 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    DBNAME
    （必需）    		 工作空间名称 此参数包含要禁用的工作空间的名称。
    DOMAINNAME
    （必需）    		 域名 此参数包含域地址。

    DISABLE DOMAIN WORKSPACE 中的可能错误代码

    7103、7138、8023、8025、8504、8506、8516、8533

    创建表

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void createtable(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME);
            string tabledesign = "{\"TABLENAME\":\"SysteTable\",\"TABLEDESCRIPTION\":\
                "Testing Purpose\",\"FOLDERNAME\": \"NewFolder\",\
                "COLUMNS\":[{\"COLUMNNAME\":\"SrNo\",\"DATATYPE\": \"NUMBER\",\"DEFAULT\":\
                "null\",\"MANDATORY\" :  \"Yes\",\"DESCRIPTION\" : \"Testing\"}]}";
            rc.CreateTable(uri, tabledesign, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.createtable(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
)

func createtable() {
        url := reportclient.GetDbUri(email, dbname)
        tableconfig := "{\"TABLENAME\": \"SystemTable\",\"TABLEDESCRIPTION\": \"
                        Testing Purpose\", \"FOLDERNAME\": \"
                        NewFolder\",\"COLUMNS\":[{\"COLUMNNAME\": \"Product Category
                        \",\"DATATYPE\": \"PLAIN\",\"DEFAULT\": \"Test\",\"MANDATORY\" :  
                        \"Yes\",\"DESCRIPTION\" :
                         \"Testing2\"}]}"
        err := reportclient.CreateTable(url, tableconfig)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        createtable()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void createtable() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        String tableDesign = "{\"TABLENAME\":\"SysteTable\",\"TABLEDESCRIPTION\"
                :\"Testing Purpose\",\"FOLDERNAME\": \"NewFolder\",
                \"COLUMNS\":[{\"COLUMNNAME\":\"SrNo\",\"DATATYPE\": \"NUMBER\",\"DEFAULT\":
                \"null\",\"MANDATORY\" :  \"Yes\",\"DESCRIPTION\" : \"Testing\"}]}"
        rc.createTable(uri,tableDesign,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.createtable();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $table_design = '{
            "TABLENAME": "SystemTable",
            "TABLEDESCRIPTION": "Testing Purpose",
            "FOLDERNAME": "NewFolder",
            "COLUMNS":
            [
                {
                "COLUMNNAME": "SrNo",
                "DATATYPE": "NUMBER",
                "DEFAULT": "null",
                "MANDATORY" :  "Yes",
                "DESCRIPTION" : "Testing"
                },
                {
                "COLUMNNAME": "Product",
                "DATATYPE": "null",
                "DEFAULT": "null",
                    "MANDATORY" :  "Yes",
                "DESCRIPTION" : "Testing2"
                },
                {
                "COLUMNNAME": "Product Category",
                "DATATYPE": "PLAIN",
                "DEFAULT": "Test",
                "MANDATORY" :  "Yes",
                "DESCRIPTION" : "Testing2"
                }
            ]
             }';
    $report_client_request->createTable($uri, $table_design);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def createtable(self,rc):
        uri = rc.getDBURI(Config.LOGINEMAILID,Config.DATABASENAME)
        tableDesign ='{\"TABLENAME\":\"SysteTable\",\"TABLEDESCRIPTION\"
                :\"Testing Purpose\",FOLDERNAME\": \"NewFolder\",
                \"COLUMNS\":[{\"COLUMNNAME\":\"SrNo\",\"DATATYPE\": \"NUMBER\",\"DEFAULT\":
                \"null\",\"MANDATORY\" :  \"Yes\",\"DESCRIPTION\" : \"Testing\"}]}'
        rc.createTable(uri,tableDesign)

obj = Sample()
obj.createtable(obj.rc)

    curl -d "ZOHO_ACTION=CREATETABLE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
         ZOHO_API_VERSION=1.0&authtoken=************&
         ZOHO_TABLE_DESIGN="Table Design in JSON""
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="CREATETABLE">
    <result>
        <message>Table created successfully!</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName",
        "action":"CREATETABLE",
        "result":
        {
            "message":"Table created successfully!"
        }
    }
}

    “创建表 API”用于在指定工作空间中创建表。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=CREATETABLE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_TABLE_DESIGN=Table_Design_In_JSON

    TABLE DESIGN

    { "TABLENAME": "Table Name", "TABLEDESCRIPTION":"Table Description", "FOLDERNAME": "Target Folder", "COLUMNS": [ { "COLUMNNAME":"Column Name 1", "DATATYPE": "Column DataType", "DEFAULT":"Default Value", "MANDATORY" : "Yes/No", "DESCRIPTION" : "Column Description" }, { "COLUMNNAME":"Column Name 2", "DATATYPE": "Column DataType", "DEFAULT":"null", "MANDATORY" : "Yes/No", "DESCRIPTION" : "Column Description" } ] }

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION CREATETABLE 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_TABLE_DESIGN
    （必需）    		 以 JSON 格式设计内容 JSON 格式的表结构（包含表名、描述、文件夹名称、列和查找详细信息）。

    CREATE TABLE 中的可能错误代码

    7103、7111、7138、8504、8506、8516、8533、8534

    自动生成报告

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void autogenreports(IReportClient rc)
        {
            try
            {
                string uri = rc.GetURI(EMAIL,DBNAME,TBNAME);
                Dictionary<string,string> param = new Dictionary<string,string>();
                param.Add("ZOHO_CREATEAGAIN", "true");
                string source = "TABLE";
                var result = rc.AutoGenReports(uri, source, param);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.autogenreports(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func autogenreports(){
        url := reportclient.GetUri(email, dbname, tbname)
        source := "TABLE"
        params := map[string]string{}
        params["ZOHO_COLUMN_NAME"] = "Region"
        result , err := reportclient.AutoGenReports(url, source, params)
        if(err != nil){
        fmt.Println(err.ErrorMessage)
        fmt.Println(err.ErrorCode)
        fmt.Println(err.Action)
        fmt.Println(err.HttpStatusCode)
        }else{
        fmt.Println(result)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        autogenreports()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void autoGenReports() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        String source = "TABLE";
        Map result = rc.autoGenReports(uri, source, null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.autoGenReports();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $source = "TABLE";
    $response = $request->autoGenReports($uri, $source);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def autogenreport(self,rc):
    uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
    source = "TABLE"
    result = rc.autoGenReports(uri,source)
    print result

obj = Sample()
obj.autogenreport(obj.rc)

    curl -d "ZOHO_ACTION=AUTOGENREPORTS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_SOURCE=TABLE"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="AUTOGENREPORTS">
    <result>
        <status>success</status>
        <message>Reports generated successfully</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
  "response": {
    "uri": "/api/EmailAddress/WorkspaceName/TableName",
    "action": "AUTOGENREPORTS",
    "result": {
      "status": "success",
      "message": "Reports generated successfully"
    }
  }
}

    “自动生成报告 API”用于在 Zoho Analytics 表中生成报告。只有帐户管理员和工作空间管理员才能使用此 API 生成报告。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=AUTOGENREPORTS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_SOURCE=TABLE

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION AUTOGENREPORTS 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_SOURCE
    （必需）    		 TABLE/COLUMN TABLE - 针对特定表生成报告。
    COLUMN - 针对特定列生成报告。
    ZOHO_CREATEAGAIN
    （可选）    		 true/false True - 如果之前生成报告，那么将生成重复报告。
    False - 如果之前生成报告，那么将抛出错误消息。
    ZOHO_COLUMN_NAME
    （SOURCE 为 COLUMN 时必需）    		 columnname 想要对其生成报告的列名。

    AUTOGENERATE REPORTS 中的可能错误代码

    7103、7107、7138、8504、8506、8516、8533

    创建类似视图

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void createsimilarviews(IReportClient rc)
        {
            try
            {
                string uri = rc.GetURI(EMAIL, "Workspace name", "Table Name");
                string refview = "Reference Table Name";
                string foldername = "Folder Name";
                string copycusformula = false;
                string copyaggformula = false;
                var result = rc.CreateSimilarViews(uri, refview, foldername, copycusformula, copyaggformula, null);
                foreach (KeyValuePair<string, string> kvp in result)
                {
                    Console.WriteLine(kvp.Key + " = " + kvp.Value);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.createsimilarviews(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "User Email"
        authtoken = "************"
)

func CreateSimilarViews(){
        url := reportclient.GetUri(email, "Workspace Name", "Table Name")
        refview := "Reference Table Name"
        foldername := "Folder Name"
        customformula := false
        aggformula := false
        params := map[string]string{}
        result , err := reportclient.CreateSimilarViews(url, refview, foldername, customformula, aggformula, params)
        if(err != nil){
        fmt.Println(err.ErrorMessage)
        fmt.Println(err.ErrorCode)
        fmt.Println(err.Action)
        fmt.Println(err.HttpStatusCode)
        }else{
        fmt.Println(result)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        CreateSimilarViews()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String databaseName = "Workspace Name";
    String tableName = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void createSimilarViews() throws Exception
    {
        String uri = rc.getURI(email,databaseName,tableName);
        String refView = "Reference Table Name";
        String folderName = "Folder Name";
        boolean customFormula = false;
        boolean aggFormula = false;
        Map result = rc.createSimilarViews(uri, refView, folderName, customFormula, aggFormula, null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.createSimilarViews();
    }
}

    <?php

    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";

    $request = new ReportClient($AUTHTOKEN);
    $uri = $request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $ref_view = "Reference Table Name";
    $folder_name = "Folder Name";
    $copy_customformula = false;
    $copy_aggformula = false;
    $response = $request->createSimilarViews($uri, $ref_view, $folder_name, $copy_customformula, $copy_aggformula);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def createSimilarViews(self,rc):
    uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
    refView = "Reference Table Name"
    folderName = "Folder Name"
    customFormula = False
    aggFormula = False
    result = rc.createSimilarViews(uri,refView,folderName,customFormula,aggFormula)

obj = Sample()
obj.createSimilarViews(obj.rc)

    curl -d "ZOHO_ACTION=CREATESIMILARVIEWS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_REFVIEW=Reference Table Name&ZOHO_FOLDERNAME=Folder Name&ISCOPYCUSTOMFORMULA=false
         &ISCOPYAGGFORMULA=false"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName/TableName" action="CREATESIMILARVIEWS">
    <result>
        <status>success</status>
        <message>Reports created successfully</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action": "CREATESIMILARVIEWS",
        "result":
        {
            "status":"Success",
            "message":"Reports created successfully"
        }
    }
}

    “创建类似视图 API”用于通过 Zoho Analytics 表生成报告。这些视图是根据引用表视图创建的。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=CREATESIMILARVIEWS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_REFVIEW=RefTable Name&ZOHO_FOLDERNAME=Folder name&ISCOPYCUSTOMFORMULA=false&ISCOPYAGGFORMULA=false

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION CREATESIMILARVIEWS 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_REFVIEW
    （必需）    		 引用视图名称 此参数包含引用视图的名称。
    ZOHO_FOLDERNAME
    （必需）    		 目标文件夹名称 此参数包含要保存视图的文件夹的名称。
    ISCOPYCUSTOMFORMULA
    （必需）    		 True / False True - 还会在新视图中复制自定义公式。
    False - 不会在新视图中处理自定义公式。
    ISCOPYAGGFORMULA
    （必需）    		 True / False True - 还会在新视图中复制汇总公式。
    False - 不会在新视图中处理汇总公式。

    CREATE SIMILAR VIEWS 中的可能错误代码

    7103、7138、7144、8504、8506、8516、8533

    重命名视图

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void renameview(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME);
            string viewname = "Old Name";
            string newviewname = "New Name";
            string viewdesc = "Description";
            rc.RenameView(uri, viewname, newviewname, viewdesc, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.renameview(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
)

func renameview() {
        url := reportclient.GetDbUri(email, dbname)
        viewname := "Old Name"
        newname := "New Name"
        newdesc := "Description"
        err := reportclient.RenameView(url, viewname, newname, newdesc)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        renameview()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void renameview() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        rc.renameView(uri,"Old Name","New Name","Description",config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.renameview();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $view_name = "Old Name";
    $new_view_name = "New Name";
    $new_view_desc = "Description";
    $$report_client_request->renameView($uri, $view_name,
                                $new_view_name, $new_view_desc);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def renameview(self,rc):
        uri = rc.getDBURI(Config.LOGINEMAILID,Config.DATABASENAME)
        rc.renameView(uri,"Old Name","New Name","Description")

obj = Sample()
obj.renameview(obj.rc)

    curl -d "ZOHO_ACTION=RENAMEVIEW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
         ZOHO_API_VERSION=1.0&authtoken=************&
         ZOHO_VIEWNAME="Old Name"&ZOHO_NEW_VIEWNAME="New Name"&ZOHO_NEW_VIEWDESC="Description""
          https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="RENAMEVIEW">
    <result>
        <message>View renamed successfully!</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName",
        "action":"RENAMEVIEW",
        "result":
        {
            "message":"View renamed successfully!"
        }
    }
}

    “重命名视图 API”用于使用新名称和描述重命名所指定视图。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=RENAMEVIEW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_VIEWNAME=Old Name&ZOHO_NEW_VIEWNAME=New Name

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION RENAMEVIEW 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_VIEWNAME
    （必需）    		 视图名称 视图的当前名称
    ZOHO_NEW_VIEWNAME
    （必需）    		 新视图名称 视图的新名称
    ZOHO_NEW_VIEWDESC
    （可选）    		 视图描述 视图的新描述

    RENAME VIEW 中的可能错误代码

    7103、7105、7111、7138、8504、8506、8516、8533

    复制报告

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void copyreports(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME);
            string views = "View1,View2";
            string dbname = "Destination Workspace Name";
            string dbkey = "************";
            rc.CopyReports(uri, views, dbname, dbkey, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.copyreports(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
        dbkey = "*************"
)

func copyreports() {
        url := reportclient.GetDbUri(email, dbname)
        viewnames := "View1,View2"
        destdbname := "Destination Workspace Name"
        err := reportclient.CopyReports(url, viewnames, destdbname, dbkey)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        copyreports()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    String dbkey = "************";
    String destdb = "Destination Workspace Name";
    String views = "View1,View2";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void copyreports() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        rc.copyReport(uri,views,destdb,dbkey,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.copyreports();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $views = "View1,View2";
    $dbname = "Destination Workspace Name";
    $dbkey = "************";
    $report_client_request->copyReports($uri, $views, $dbname, $dbkey);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def copyreports(self,rc):
        uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
        rc.copyReports(uri,"View1,View2","Destination Workspace Name","***********")

obj = Sample()
obj.copyreports(obj.rc)

    curl -d "ZOHO_ACTION=COPYREPORTS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
         ZOHO_API_VERSION=1.0&authtoken=************&
         ZOHO_VIEWTOCOPY=View1,View2&ZOHO_DATABASE_NAME=Destination Workspace name&
         ZOHO_COPY_DB_KEY=************"
         https://analyticsapi.zoho.com/api/SourceEmailAddress/SourceWorkspaceName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName" 
                action="COPYREPORTS">
    <result>
        <message>
        Successfully View(s) Copied
        </message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName",
        "action":"COPYREPORTS",
        "result":
        {
            "message": "Successfully View(s) Copied"
        }
    }
}

    源工作空间管理员应生成并提供复制工作空间密钥，这是用于向目标工作空间管理员授权的密钥。使用此 API 复制报告时，将复制报告、所涉及关系以及与源报告相关联的公式列。源工作空间中的视图的父表应以相同名称存在于目标工作空间中。

    http 请求

    https://analyticsapi.zoho.com/api/SourceEmailAddress/SourceWorkspaceName?ZOHO_ACTION=COPYREPORTS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************(Destination user authtoken)&ZOHO_VIEWTOCOPY=EmployeeDetails&ZOHO_DATABASE_NAME=Destination Workspace Name&ZOHO_COPY_DB_KEY=************(Source workspace key)

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION COPYREPORTS 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_VIEWTOCOPY
    （必需）    		 视图名称 此参数包含视图名称的列表。如果有多个视图，那么视图名称之间应使用逗号 (,) 分隔。Example:ZOHO_VIEWTOCOPY=View1,View2,View3,…
    ZOHO_DATABASE_NAME
    （必需）    		 工作空间名称 此参数包含必须在其中复制报告（在 ZOHO_VIEWSTOCOPY 参数中指定）的工作空间（目标工作空间）的名称。
    ZOHO_COPY_DB_KEY
    （必需）    		 工作空间密钥 用于允许用户复制工作空间/报告的密钥。
    源工作空间管理员必须调用以下 URL 以获取复制工作空间密钥。
    https://analyticsapi.zoho.com/api/abcd@zoho.com/SourceEmployeeDB?ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&authtoken=<source_workspace_admin_authtoken>&ZOHO_API_VERSION=1.0.
    有关工作空间密钥的更多信息。
    Note:     您需要在以上 URL 中提供相应值，以便为您的设置生成相应的复制工作空间密钥。

    COPY REPORTS 中的可能错误代码

    7103、7138、8504、8506、8516、8533、15000、15001、15002、15005、15007、15012

    复制公式

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void copyformula(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
            string formula = "Formula1,Formula2";
            string dbname = "Destination Workspace Name";
            string dbkey = "***********";
            rc.CopyFormula(uri, formula, dbname, dbkey, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.copyformula(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
        dbkey = "************"
)

func copyformula() {
        url := reportclient.GetUri(email, dbname, tbname)
        formulaname := "Formula1,Formula2"
        destdbname := "Destination Workspace Name"
        err := reportclient.CopyFormula(url, formulaname, destdbname, dbkey)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        copyformula()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    String dbkey = "*************";
    String destdb = "Formula1";
    String formula = "Destination Workspace Name";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void copyformula() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        rc.copyFormula(uri,formula,destdb,dbkey,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.copyformula();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $formula = "Formula1";
    $dbname = "Destination Workspace Name";
    $dbkey = "*************";
    $report_client_request->copyFormula($uri, $formula, $dbname, $dbkey);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def copyformula(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        rc.copyFormula(uri,"Formula1","Destination Workspace Name","************")

obj = Sample()
obj.copyformula(obj.rc)

    curl -d "ZOHO_ACTION=COPYFORMULA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
         ZOHO_API_VERSION=1.0&authtoken=************&
         ZOHO_FORMULATOCOPY=Formula1&ZOHO_DATABASE_NAME=Destination Workspace Name&
         ZOHO_COPY_DB_KEY=*************"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName/TableName"
                 action="COPYFORMULA">
    <result>
        <message>
        Successfully formula(s) Copied
        </message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
         {
            "uri":"\/api\/EmailAddress\/Workspace name\/TableName",
            "action":"COPYFORMULA",
            "result":
        {
                         "message": "Successfully Formula(s) Copied"
        }
    }
}

    “复制公式 API”用于将一个或多个公式列从同一个工作空间中的一个表复制到另一个表、跨工作空间复制，甚至从一个用户帐户复制到另一个用户帐户。源工作空间管理员应生成并提供复制工作空间密钥，这是用于向目标工作空间管理员授权的密钥。目标工作空间中的表和列名必须与公式所依赖的源工作空间中的表名和列名相同。可使用此 API 复制自定义公式和汇总公式。

    http 请求

    https://analyticsapi.zoho.com/api/SourceEmailAddress/SourceWorkspaceName/SourceTableName?ZOHO_ACTION=COPYFORMULA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************(Destination user token)&ZOHO_FORMULATOCOPY=MyFormula1&ZOHO_DATABASE_NAME=Destination Workspace Name&ZOHO_COPY_DB_KEY=**********(Source Workspace key)

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION COPYFORMULA 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_FORMULATOCOPY 公式名称 此参数包含要从源工作空间复制到目标工作空间中的另一个表的公式名称。
    如果要复制多个公式，公式名称之间应使用逗号 (,) 分隔。
    Example: ZOHO_FORMULATOCOPY=MyFormula1,MyFormula2,MyFormulaN
    ZOHO_DATABASE_NAME 工作空间名称 此参数包含目标表所在的工作空间（目标工作空间）的名称。
    所指定公式将复制到具有 API URL 中指定的名称 (SourceEmployeeDetails) 的表中
    ZOHO_COPY_DB_KEY 工作空间密钥 用于允许用户复制工作空间/报告的密钥。
    源工作空间管理员必须调用以下 URL 以获取复制工作空间密钥。
    https://analyticsapi.zoho.com/api/abcd@zoho.com/SourceEmployeeDB?ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&authtoken=<source_db_owner_authtoken>&ZOHO_API_VERSION=1.0 .
    有关工作空间密钥的更多信息。
    Note: 您需要在以上 URL 中提供相应值，以便为您的设置生成相应的复制工作空间密钥。

    COPY FORMULA 中的可能错误代码

    7103、7138、8504、8506、8516、8533、15002、15007、15009、15010

    添加栏

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void addColumn(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            string ColumnName = "Column Name";
            string DataType = "PLAIN";
            bool HideColumn = false;
            bool SkipSystemTableCheck = true;
            RepClient.AddColumn(tableURI, ColumnName, DataType, HideColumn,
                                       SkipSystemTableCheck, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.addColumn(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func addcolumn() {
        url := reportclient.GetUri(email, dbname, tbname)
        columnname := "Column Name"
        datatype := "PLAIN"
        err := reportclient.AddColumn(url, columnname, datatype)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        addcolumn()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void addcolumn() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        rc.addColumn(uri,"DOB","PLAIN",config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.addcolumn();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $column_name = "Column Name";
    $data_type = "PLAIN";
    $report_client_request->addColumn($uri, $column_name, $data_type);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def AddColumn(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        columnName = "Column Name"
        dataType = "PLAIN"
        rc.addColumn(uri,columnName,dataType)

obj = Sample()
obj.AddColumn(obj.rc)

    curl -d "ZOHO_ACTION=ADDCOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_COLUMNNAME=Column Name&ZOHO_DATATYPE=Column Data Type"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName/TableName" action="ADDCOLUMN">
    <result>
        Column created successfully
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action":"ADDCOLUMN",
        "result": {"message":"Column created successfully"}
        }
}

    “添加列 API”用于向 Zoho Analytics 表添加列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中添加列。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=ADDCOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=Column Name&ZOHO_DATATYPE=Data Type

    Note: 工作空间所有者添加列时，他们只需要指定帐户管理员的登录电子邮件 ID。

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION ADDCOLUMN 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_COLUMNNAME
    （必须）    		 <columnname> 要添加至 Zoho Analytics 表的列的名称。
    Example:ZOHO_COLUMNNAME=Region。
    Note: 如果列名包含空格或任意特殊字符，那么应使用 URL 编写列名。
    ZOHO_DATATYPE
    （必需）    		 受支持的数据类型包括：
  • PLAIN
  • MULTI_LINE
  • EMAIL
  • NUMBER
  • POSITIVE_NUMBER
  • DECIMAL_NUMBER
  • CURRENCY
  • PERCENT
  • DATE
  • BOOLEAN
  • URL
  • AUTO_NUMBER
    		•  要添加至 Zoho Analytics 表的列的数据类型。

    ADD COLUMN 中的可能错误代码

    7103、7128、7138、7161、8504、8506、8516、8533

    删除列

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void deleteColumn(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            string ColumnName = "Column Name";
            bool DeleteDependentView = false;
            bool SkipSystemTableCheck = true;
            RepClient.DeleteColumn(tableURI, ColumnName, DeleteDependentView,
                 SkipSystemTableCheck, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.deleteColumn(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func deletecolumn() {
        url := reportclient.GetUri(email, dbname, tbname)
        columnname := "Column Name"
        err := reportclient.DeleteColumn(url, columnname)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        deletecolumn()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void deletecolumn() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        rc.deleteColumn(uri,"Column Name",config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.deletecolumn();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $column_name = "Column Name";
    $report_client_request->deleteColumn($uri, $column_name);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def DeleteColumn(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        columnName = "Column Name"
        rc.deleteColumn(uri,columnName)

obj = Sample()
obj.DeleteColumn(obj.rc)

    curl -d "ZOHO_ACTION=DELETECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_COLUMNNAME=Column Name"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName/TableName" action="DELETECOLUMN">
    <result>
        Column deleted successfully
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action":"DELETECOLUMN",
        "result": {"message":"Column deleted successfully"}
    }
}

    “删除列 API”用于在 Zoho Analytics 表中删除列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中删除列。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=DELETECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=COlumn Name

    Note: 工作空间管理员删除列时，他们只需要指定帐户管理员的登录电子邮件 ID。

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION DELETECOLUMN 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于 CTION 的参数

    参数名称 可能的值 描述
    ZOHO_COLUMNNAME
    （必须）    		 <columnname> 要在 Zoho Analytics 表中删除的列的名称。
    Example:ZOHO_COLUMNNAME=Region

    DELETE COLUMN 中的可能错误代码

    7103、7107、7138、7159、8504、8506、8516、8533

    重命名列

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void renameColumn(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            string OldColumnName = "Old Column Name";
            string NewColumnName = "New Column Name";
            bool SkipSystemTableCheck = true;
            RepClient.RenameColumn(tableURI, OldColumnName, NewColumnName,
                                 SkipSystemTableCheck, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.renameColumn(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func renamecolumn() {
        url := reportclient.GetUri(email, dbname, tbname)
        oldcolumnname := "Old Column Name"
        newcolumnname := "New Column Name"
        err := reportclient.RenameColumn(url, oldcolumnname, newcolumnname)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        renamecolumn()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void renamecolumn() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        rc.renameColumn(uri,"Old Column Name","New Column Name",config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.renamecolumn();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $old_column_name = "Old Column Name";
    $new_column_name = "New Column Name";
    $report_client_request->renameColumn($uri, $old_column_name,
                                     $new_column_name);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def RenameColumn(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        oldColumnName = "Old Column Name"
        newColumnName = "New Column Name"
        rc.renameColumn(uri,oldColumnName,newColumnName)

obj = Sample()
obj.RenameColumn(obj.rc)

    curl -d "ZOHO_ACTION=RENAMECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &OLDCOLUMNNAME=Old Column Name&NEWCOLUMNNAME=New Column Name"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName/TableName" action="RENAMECOLUMN">
    <result>
        Column renamed successfully
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action":"RENAMECOLUMN",
        "result":
        {
            "message":"Column renamed successfully"
        }
    }
}

    “重命名列 API”用于在 Zoho Analytics 表中重命名列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中重命名列。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=RENAMECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&OLDCOLUMNNAME=Old Column Name&NEWCOLUMNNAME=New Column Name

    Note: 工作空间管理员重命名列时，他们只需要指定帐户管理员的登录电子邮件 ID。

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION RENAMECOLUMN 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    OLDCOLUMNNAME
    （必需）    		 <oldcolumnname> 要在 Zoho Analytics 表中重命名的列的名称。 Example: OLDCOLUMNNAME=Region
    NEWCOLUMNNAME
    （必需）    		 <newcolumnname> 要对该列指定的新名称。Example:NEWCOLUMNNAME=SalesRegion

    RENAME COLUMN 中的可能错误代码

    7103、7107、7138、7128、8504、8506、8516、8533

    隐藏列

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void hidecolumn(IReportClient rc)
        {
            try
            {
                string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
                string[] columnNames = new string[3];
                columnNames[0] = "COlumn1";
                columnNames[1] = "COlumn2";
                columnNames[2] = "Column3";
                var result = rc.HideColumn(uri,columnNames,null);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.hidecolumn(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func hidecolumn(){
        url := reportclient.GetUri(email, dbname, tbname)
        columnnames := []string{"Column1" , "Column2" , "Column3"}
        params := map[string]string{}
        result , err := reportclient.HideColumn(url, columnnames, params)
        if(err != nil){
        fmt.Println(err.ErrorMessage)
        fmt.Println(err.ErrorCode)
        fmt.Println(err.Action)
        fmt.Println(err.HttpStatusCode)
        }else{
        fmt.Println(result)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        hidecolumn()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void hidecolumn() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        List columnNames = new ArrayList();
        columnNames.add("Column1");
        columnNames.add("Column2");
        Map result = rc.hideColumn(uri, columnNames, null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.hidecolumn();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $columnNames = array("Column1","Column2");
    $response = $request->hideColumn($uri ,$columnNames);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def hidecolumn(self,rc):
    uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
    params = []
    params.append("Column1")
    params.append("Column2")
    params.append("Column3")
    result = rc.hideColumn(uri,params)
    print result

obj = Sample()
obj.hidecolumn(obj.rc)

    curl -d "ZOHO_ACTION=HIDECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_COLUMNNAME=Column1&ZOHO_COLUMNNAME=Column2"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="HIDECOLUMN">
    <result>
        <column columnName="Column1" status="Success" message="column hidden successfully"> </column>
    </result>
</response>

    样本响应 JSON 格式：

    {
  "response": {
    "uri": "/api/EmailAddress/WorkspaceName/TableName",
    "action": "HIDECOLUMN",
    "result": [
      {
        "columnName": "Column1",
        "status": "Success",
        "message": "column hidden successfully"
      }
    ]
  }
}

    “隐藏列 API”用于在 Zoho Analytics 表中隐藏列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中隐藏列。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=HIDECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=Column1&ZOHO_COLUMNNAME=Column2

    Note: 工作空间管理员隐藏列时，他们只需要指定帐户管理员的登录电子邮件 ID。

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION HIDECOLUMN 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_COLUMNNAME
    （必须）    		 <columnname> 要在 Zoho Analytics 表中隐藏的列的名称。 Example: ZOHO_COLUMNNAME=Region。
    注：允许使用多个参数。

    HIDE COLUMN 中的可能错误代码

    7103、7107、7138、8504、8506、8516、8533

    显示列

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void showcolumn(IReportClient rc)
        {
            try
            {
                string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
                string[] columnNames = new string[3];
                columnNames[0] = "Column1";
                columnNames[1] = "Column2";
                columnNames[2] = "Column3";
                var result = rc.ShowColumn(uri,columnNames,null);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.showcolumn(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func showcolumn(){
        url := reportclient.GetUri(email, dbname, tbname)
        columnnames := []string{"Column1" , "Column2" , "Column3"}
        params := map[string]string{}
        result , err := reportclient.ShowColumn(url, columnnames, params)
        if(err != nil){
        fmt.Println(err.ErrorMessage)
        fmt.Println(err.ErrorCode)
        fmt.Println(err.Action)
        fmt.Println(err.HttpStatusCode)
        }else{
        fmt.Println(result)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        showcolumn()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void showcolumn() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        List columnNames = new ArrayList();
        columnNames.add("Column1");
        columnNames.add("Column2");
        Map result = rc.showColumn(uri, columnNames, null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.showcolumn();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $columnNames = array("Column1","Column2");
    $response = $request->showColumn($uri ,$columnNames);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def showcolumn(self,rc):
    uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
    params = []
    params.append("Column1")
    params.append("Column2")
    params.append("Column3")
    result = rc.showColumn(uri,params)
    print result

obj = Sample()
obj.showcolumn(obj.rc)

    curl -d "ZOHO_ACTION=SHOWCOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_COLUMNNAME=Column1&ZOHO_COLUMNNAME=Column2"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="SHOWCOLUMN">
    <result>
        <column columnName="Column1" status="Success" message="column shown successfully"> </column>
    </result>
</response>

    样本响应 JSON 格式：

    {
  "response": {
    "uri": "/api/EmailAddress/WorkspaceName/TableName",
    "action": "SHOWCOLUMN",
    "result": [
      {
        "columnName": "Column1",
        "status": "Success",
        "message": "column shown successfully"
      }
    ]
  }
}

    “显示列 API”用于在 Zoho Analytics 表中显示列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中显示列。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=SHOWCOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=COlumn1&ZOHO_COLUMNNAME=Column2

    Note: 工作空间管理员显示列时，他们只需要指定帐户管理员的登录电子邮件 ID。

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION SHOWCOLUMN 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_COLUMNNAME
    （必须）    		 <columnname> 要在 Zoho Analytics 表中显示的列的名称。 Example: ZOHO_COLUMNNAME=Region。
    注：允许使用多个参数。

    SHOW COLUMN 中的可能错误代码

    7103、7107、7138、8504、8506、8516、8533

    添加查找

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void addlookup(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
            string columnname = "Column Name";
            string reftable = "Ref Table Name";
            string refcolumn = "Ref Column Name";
            string onerror = "ABORT";
            rc.AddLookup(uri, columnname, reftable, refcolumn, onerror, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.addlookup(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func addlookup() {
        url := reportclient.GetUri(email, dbname, tbname)
        columnname := "COlumn Name Name"
        refertable := "Ref Table Name"
        refercolumn := "Ref Column Name"
        onerror := "ABORT"
        err := reportclient.AddLookup(url, columnname, refertable, refercolumn
                                        , onerror)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        addlookup()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void addlookup() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        rc.addLookup(uri,"Column Name","Ref Table Name","Ref Column Name","ABORT",config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.addlookup();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $column_name = "Column Name";
    $referred_table = "Ref Table Name";
    $referred_column = "Ref Column Name";
    $on_error = "ABORT";
    $report_client_request->addLookup($uri, $column_name, $referred_table,
                   $referred_column, $on_error);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def addlookup(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        result = rc.addLookup(uri,"Column Name","Ref Table Name","Ref Column Name","ABORT")

obj = Sample()
obj.addlookup(obj.rc)

    curl -d "ZOHO_ACTION=ADDLOOKUP&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
         ZOHO_API_VERSION=1.0&authtoken=************&
         ZOHO_COLUMNNAME="Column Name"&ZOHO_REFERREDTABLE="Ref Table Name"&
         ZOHO_REFERREDCOLUMN="Ref Column Name"&ZOHO_IFERRORONCONVERSION="ABORT""
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="ADDLOOKUP">
    <result>SUCCESS</result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action":"ADDLOOKUP",
        "result":"SUCCESS"
    }
}

    “添加查找 API”用于在所指定子表中添加查找。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=ADDLOOKUP&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=Column Name&ZOHO_REFERREDTABLE=Ref Table Name&ZOHO_REFERREDCOLUMN=Ref Column Name&ZOHO_IFERRORONCONVERSION=ABORT

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION ADDLOOKUP 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_COLUMNNAME
    （必须）    		 <columnname> 要添加至 Zoho Analytics 表的列的名称。
    Example:ZOHO_COLUMNNAME=Region。
    Note: 如果列名包含空格或任意特殊字符，那么应使用 URL 编写列名。
    ZOHO_REFERREDTABLE
    （必需）    		 表名 被引用表的名称。
    ZOHO_REFERREDCOLUMN
    （必需）    		 列名 被引用表中的列的名称。
    ZOHO_IFERRORONCONVERSION
    （必需）    		 ABORT/EMPTY 如果转换时发生错误。

    ADD LOOKUP 中的可能错误代码

    7103、7107、7138、8504、8506、8516、8533

    移除查找

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void removelookup(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
            string columnname = "Column Name";
            rc.RemoveLookup(uri, columnname, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.removelookup(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func removelookup() {
        url := reportclient.GetUri(email, dbname, tbname)
        columnname := "Column Name"
        err := reportclient.RemoveLookup(url, columnname)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        removelookup()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void removelookup() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        rc.removeLookup(uri,"Column Name",config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.removelookup();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $column_name = "Column Name";
    $report_client_request->removeLookup($uri, $column_name);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def removelookup(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        result = rc.removeLookup(uri,"Column Name")

obj = Sample()
obj.removelookup(obj.rc)

    curl -d "ZOHO_ACTION=REMOVELOOKUP&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=JSON&
         ZOHO_API_VERSION=1.0&authtoken=************&
         ZOHO_COLUMNNAME="Column Name""
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="REMOVELOOKUP">
    <result>SUCCESS</result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action":"REMOVELOOKUP",
        "result":"SUCCESS"
    }
}

    “移除查找 API”用于移除针对给定表中的指定列的查找。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=REMOVELOOKUP&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=Column Name

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION REMOVELOOKUP 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_COLUMNNAME
    （必须）    		 <columnname> 要添加至 Zoho Analytics 表的列的名称。
    Example:ZOHO_COLUMNNAME=Region。
    Note: 如果列名包含空格或任意特殊字符，那么应使用 URL 编写列名。

    REMOVE LOOKUP 中的可能错误代码

    7103、7107、7138、8504、8506、8516、8533

    “建模 API”中的错误代码

    样本错误 XML 格式：

    
<response uri="/api/EmailAddress/WorkspaceName" action="COPYDATABASE">
    <error>
        <code>7103</code>
        <message>
        Workspace not found! Please check whether the Workspace exists
        </message>
    </error>
</response>

    样本错误 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName",
        "action": "COPYDATABASE",
        "error":
        {
        "code":7103,
        "message": "Workspace not found! Please check whether
                               the Workspace exists"
        }
    }
}

    本节列示“建模 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。

    错误代码

    错误代码 原因 解决方案
    7101 同名工作空间已存在。 请提供另一名称。
    7103 API URL 中提到的工作空间名称不存在。 检查请求 URL 中的工作空间名称，并提供有效的工作空间名称。
    7105 工作空间中指定的视图名称不存在。 请提供有效视图名称。
    7107 该列在所指定 Zoho Analytics 表中不存在。 请在 ZOHO_COLUMNNAME 参数中提供要删除的列的正确名称。
    7111 带有该名称的表在此工作空间中已存在。 请提供另一名称。
    7128 带有相同名称的列在 Zoho Analytics 表中已存在。 请对 ZOHO_COLUMNNAME 参数提供不同名称。
    7138 API 请求 URL 中指定的视图名称不存在。 检查请求 URL 中的视图名称并提供有效的视图名称。
    7144 所提及文件夹在此工作空间中不存在。 请检查所提及文件夹是否可用。
    7159 要删除的列用于报告、公式列、查询表等等。 无法删除带有关联视图的列。调用此“删除列 API”之前，请删除与此列相关的关联视图和公式列。
    7161 此 API 中指定的 Zoho Analytics 表是系统表（针对服务集成创建的表）。 不允许在系统表中添加列。使用此 API 时只能在非系统表中添加列。
    7165 所指定工作空间是无法删除的系统工作空间（专为其他 Zoho 服务集成创建的工作空间）。 无法删除系统工作空间。
    8023 您无权执行此操作。 请联系我们的支持团队。
    8024 不允许执行“复制工作空间”操作。 请检查 URL 中提供的工作空间密钥。
    8025 无效自定义域。 请提供有效域名。
    8504 所需参数不正确或未发送。 请发送带有有效数据的参数。
    8506 所提及参数的已发送次数超过所需次数。 检查响应中提及的额外参数并移除。
    8516 所提及参数中传递了无效值。 对所提及参数提供有效数据。
    8533 URL 中提供的用户电子邮件地址为错误格式。 请提供有效电子邮件地址。
    8534 无效的 JSON 格式。 请提供有效 JSON 数据。
    15000 目标工作空间中缺少复制所指定报告时所需的表。 检查目标工作空间并创建缺少的表。
    15001 目标工作空间中缺少复制所指定报告时所需的列。 检查目标工作空间并在复制报告之前创建该列。
    15002 目标工作空间中缺少复制所指定报告时所需的公式列。 检查目标工作空间并在复制报告之前创建公式列。
    15005 所指定报告名称已存在于目标工作空间中。 检查目标工作空间中是否存在同名报告。尝试重命名源报告或目标工作空间中的报告，然后再次调用该 API。
    15007 权限不足，无法复制报告。 检查复制工作空间密钥是否有效。
    15009 所指定公式列名已存在于目标工作空间中。 检查公式列是否已被复制，或者尝试重命名源表或目标工作空间中的公式列，然后再次调用该 API。
    15010 API 请求中指定的公式列名称不在源表中。 检查 ZOHO_FORMULATOCOPY 参数中指定的公式列名称是否正确。
    15012 API 请求中指定的报告不在源工作空间中。 检查 ZOHO_VIEWTOCOPY 参数中指定的报告是否正确并可用。

    如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至 support@zohoanalytics.com。Zoho Analytics 团队将回复您并给出最佳可行解决方案。

    元数据 API

    本节列示所有元数据 API。元数据 API 可用于获取有关报告 Zoho Analytics 中创建的工作空间、表、报告和统计图表的信息。

    工作空间元数据

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void getDatabaseMetaData(IReportClient RepClient)
        {
            string dbURI = RepClient.GetURI(EMAIL, DBNAME);
            string metaData = "ZOHO_CATALOG_INFO";
            string format = "XML"
            string result = RepClient.GetDatabaseMetaData(dbURI, metaData, format, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.getDatabaseMetaData(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
)

func databasemetadata() {
        url := reportclient.GetUserUri(email)
        metadata := "ZOHO_CATALOG_LIST"
        data , err := reportclient.GetDatabaseMetadata(url, metadata)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(data)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        databasemetadata()
}

    import java.util.HashMap;
import java.util.Map;

import org.w3c.dom.Document;

import com.adventnet.zoho.client.report.*;

public class Sample
{

        String authtoken = "************";
        String email = "Email Address";
        Map<String, String> config = new HashMap<String, String>();

        private ReportClient rc = new ReportClient(authtoken);

        public void metadata() throws Exception
        {
                String uri = rc.getURI(email);
                Document result = rc.getDatabaseMetaData(uri,"ZOHO_CATALOG_LIST",config);
        }

        public static void main(String[] args)
        throws Exception
        {
                Sample obj = new Sample();
                obj.metadata();
        }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getUserURI($EMAIL_ID);
    $metadata = "ZOHO_CATALOG_LIST";
    $report_client_response = $report_client_request->getDatabaseMetadata($uri, $metadata);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def getdatabasemetadata(self,rc):
        uri = rc.getUserURI(self.LOGINEMAILID)
        result = rc.getDatabaseMetadata(uri,"ZOHO_CATALOG_LIST")
        print result

obj = Sample()
obj.getdatabasemetadata(obj.rc)

    curl -d "ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=
         XML&ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_METADATA=ZOHO_CATALOG_LIST"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <response URI="/api/EmailAddress" ACTION="ZOHO_CATALOG_LIST">
    <ZCATALOGS>
        <ZCATALOG IS_DEFAULT="1" TABLE_CAT="SalesDB"></ZCATALOG>
        <ZCATALOG IS_DEFAULT="0" TABLE_CAT="Super Store Sales"></ZCATALOG>
        <ZCATALOG IS_DEFAULT="0" TABLE_CAT="Project Manager"></ZCATALOG>
    </ZCATALOGS>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "ZOHO_CATALOG_LIST",
        "result":
        [
        {
            "isDefault": true,
            "tableCat": "SalesDB"
        },
        {
            "isDefault": false,
            "tableCat": "Super Store Sales"
        },
        {
            "isDefault": false,
            "tableCat": "Project Manager"
        }
        ]
    }
}

    目录信息的样本响应

    XML 格式：

    <response URI="/api/EmailAddress/WorkspaceName" ACTION="ZOHO_CATALOG_INFO">
    <ZCATALOG TABLE_CAT="SalesDB">
    <ZVIEW REMARKS="\N" TABLE_NAME="SalesTable" TABLE_TYPE="TABLE">
    <ZCOLUMNS>
        <ZCOLUMN COLUMN_NAME="REGION" PKCOLUMN_NAME="\N" NULLABLE="true"
        COLUMN_SIZE="100"PKTABLE_NAME="\N" DATA_TYPE="12" REMARKS="\N"
        TYPE_NAME="Plain Text"
        DECIMAL_DIGITS="-1" ORDINAL_POSITION="1"></ZCOLUMN>
        <ZCOLUMN COLUMN_NAME="Order Date" PKCOLUMN_NAME="\N" NULLABLE="true"
        COLUMN_SIZE="19"
        PKTABLE_NAME="\N" DATA_TYPE="93" REMARKS="\N" TYPE_NAME="Date"
        DECIMAL_DIGITS="-1" ORDINAL_POSITION="6"></ZCOLUMN>
    </ZCOLUMNS>
    </ZVIEW>
    <ZVIEW REMARKS="\N" TABLE_NAME="Region" TABLE_TYPE="REPORT"></ZVIEW>
    <ZVIEW REMARKS="\N" TABLE_NAME="SalesTabular" TABLE_TYPE="REPORT">
    <ZVIEW REMARKS="\N" TABLE_NAME="SalesQuery" TABLE_TYPE="VIEW">
    <ZCOLUMNS>
        <ZCOLUMN COLUMN_NAME="Market Type" PKCOLUMN_NAME="\N"NULLABLE="false"
        COLUMN_SIZE="100"
        PKTABLE_NAME="\N" DATA_TYPE="12" REMARKS="\N" TYPE_NAME="Plain Text"
        DECIMAL_DIGITS="-1" ORDINAL_POSITION="1"></ZCOLUMN>
        <ZCOLUMN COLUMN_NAME="Order Date" PKCOLUMN_NAME="\N"NULLABLE="false"
        COLUMN_SIZE="19"
        PKTABLE_NAME="\N" DATA_TYPE="93" REMARKS="\N" TYPE_NAME="Date"
        DECIMAL_DIGITS="-1" ORDINAL_POSITION="2"></ZCOLUMN>
    </ZCOLUMNS>
    </ZVIEW>
    <ZVIEW REMARKS="\N" TABLE_NAME="SalesPivot" TABLE_TYPE="REPORT"></ZVIEW>
    <ZVIEW REMARKS="\N" TABLE_NAME="SalesSummary" TABLE_TYPE="REPORT"></ZVIEW>
</response>

    JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName",
        "action": "ZOHO_CATALOG_INFO",
        "result":
        {
            "views":
            [
            {
                "remarks": null,
                "tableName": "SalesTable",
                "tableType": "TABLE",
                "columns":
                [
                {
                    "columnName": "REGION",
                    "pkcolumnName": null,
                    "nullable": true,
                    "columnSize": 100,
                    "pktableName": null,
                    "dataType": "12",
                    "remarks": null,
                    "typeName": "Plain Text",
                    "decimalDigits": -1,
                    "ordinalPosition": 1
                },
                {
                    "columnName": "Order Date",
                    "pkcolumnName": null,
                    "nullable": true,
                    "columnSize": 19,
                    "pktableName": null,
                    "dataType": "93",
                    "remarks": null,
                    "typeName": "Date",
                    "decimalDigits": -1,
                    "ordinalPosition": 6
                }
                ]
            },
            {
                "remarks": "Region wise chart for the year 2009",
                "tableName": "Region",
                "tableType": "REPORT",
                "columns":
                [
                ]
            },
            {
                "remarks": null,
                "tableName": "SalesTabular",
                "tableType": "REPORT",
                "columns":
                [
                ]
            },
            {
                "remarks": null,
                "tableName": "SalesQuery",
                "tableType": "VIEW",
                "columns":
                [
                {
                    "columnName": "Market Type",
                    "pkcolumnName": null,
                    "nullable": false,
                    "columnSize": 100,
                    "pktableName": null,
                    "dataType": "12",
                    "remarks": null,
                    "typeName": "Plain Text",
                    "decimalDigits": -1,
                    "ordinalPosition": 1
                },
                {
                    "columnName": "Order Date",
                    "pkcolumnName": null,
                    "nullable": false,
                    "columnSize": 19,
                    "pktableName": null,
                    "dataType": "93",
                    "remarks": null,
                    "typeName": "Date",
                    "decimalDigits": -1,
                    "ordinalPosition": 2
                }
                ]
            },
            {
                "remarks": null,
                "tableName": "SalesPivot",
                "tableType": "REPORT",
                "columns":
                [
                ]
            },
            {
                "remarks": null,
                "tableName": "SalesSummary",
                "tableType": "REPORT",
                "columns":
                [
                ]
            }
            ],
            "tableCat": "SalesDB"
        }
    }
}

    数据类型信息的样本响应

    XML 格式：

    <response URI="/api/EmailAddress" ACTION="ZOHO_DATATYPES">
    <ZDATATYPES>
        <ZDATATYPE LITERAL_PREFIX="&apos;" MAXSIZE="19" MAXIMUM_SCALE="\N"
        NULLABLE="1"
        TYPE_NAME="Positive Number" DATA_TYPE="-5" MINIMUM_SCALE="\N"
        SQL_DATA_TYPE="-5"
        FIXED_PREC_SCALE="false" LOCAL_TYPE_NAME="\N" AUTO_INCREMENT="false"
        SQL_DATETIME_SUB="0" PRECISION="-1" UNSIGNED_ATTRIBUTE="true" ID="5">
        </ZDATATYPE>
        <ZDATATYPE LITERAL_PREFIX="&apos;" MAXSIZE="1" MAXIMUM_SCALE="\N"
        NULLABLE="1"
        TYPE_NAME="Yes/No Decision" DATA_TYPE="-7" MINIMUM_SCALE="\N"
        SQL_DATA_TYPE="-7"
        FIXED_PREC_SCALE="false" LOCAL_TYPE_NAME="\N" AUTO_INCREMENT="false"
        SQL_DATETIME_SUB="0" PRECISION="-1" UNSIGNED_ATTRIBUTE="false" ID="10">
        </ZDATATYPE>
    </ZDATATYPES>
</response>

    JSON 格式

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "ZOHO_DATATYPES",
        "result":
        [
        {
            "literalPrefix": "\'",
            "maxsize": 19,
            "maximumScale": null,
            "nullable": true,
            "dataType": -5,
            "minimumScale": null,
            "sqlDataType": -5,
            "fixedPrecScale": false,
            "localTypeName": null,
            "autoIncrement": false,
            "searchable": false,
            "literalSuffix": "\'",
            "caseSensitive": true,
            "numPrecRadix": "10",
            "typeName": "Positive Number",
            "createParams": "500",
            "sqlDatetimeSub": "0",
            "precision": -1,
            "unsignedAttribute": true,
            "id": "5"
        },
        {
            "literalPrefix": "\'",
            "maxsize": 1,
            "maximumScale": null,
            "nullable": true,
            "dataType": -7,
            "minimumScale": null,
            "sqlDataType": -7,
            "fixedPrecScale": false,
            "localTypeName": null,
            "autoIncrement": false,
            "searchable": false,
            "literalSuffix": "\'",
            "caseSensitive": true,
            "numPrecRadix": "10",
            "typeName": "Yes\/No Decision",
            "createParams": "500",
            "sqlDatetimeSub": "0",
            "precision": -1,
            "unsignedAttribute": false,
            "id": "10"
        }
        ]
    }
}

    表类型的样本响应

    XML 格式：

    <response URI="/api/EmailAddress" ACTION="ZOHO_TABLETYPES">
    <ZVIEWTYPES >
        <ZVIEWTYPE TYPE="TABLE"></ZVIEWTYPE>
        <ZVIEWTYPE TYPE="VIEW"></ZVIEWTYPE>
        <ZVIEWTYPE TYPE="REPORT"></ZVIEWTYPE>
    </ZVIEWTYPES>
</response>

    JSON 格式

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "ZOHO_TABLETYPES",
        "result":
        [
            "TABLE",
            "VIEW",
            "REPORT"
        ]
    }
}

    通过使用“工作空间元数据 API”，您可获取以下元信息。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_CATALOG_LIST

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION DATABASEMETADATA 此参数指定 API 请求要执行的操作。
    ZOHO_METADATA 受支持的值为：
  • ZOHO_CATALOG_LIST：列示所指定用户的 Zoho Analytics 工作空间
  • ZOHO_CATALOG_INFO：获取有关 Zoho Analytics 内给定报告工作空间中的表和报告（视图）的信息。
  • ZOHO_DATATYPES：获取 Zoho Analytics 支持的数据类型列表
  • ZOHO_TABLETYPES：Zoho Analytics 中的各种可用视图类型
    		•  指定要获取的信息。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    1. 获取工作空间（目录）列表

    列示所指定用户的 Zoho Analytics 工作空间

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_CATALOG_LIST

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION DATABASEMETADATA 此参数指定 API 请求要执行的操作。
    ZOHO_METADATA ZOHO_CATALOG_LIST 列示所指定用户的 Zoho Analytics 工作空间
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    2. 获取工作空间中的表和报告（目录信息）

    获取有关 Zoho Analytics 内给定报告工作空间中的表和报告（视图）的信息。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_CATALOG_INFO

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION DATABASEMETADATA 此参数指定 API 请求要执行的操作。
    ZOHO_METADATA ZOHO_CATALOG_INFO 获取有关 Zoho Analytics 内给定报告工作空间中的表和报告（视图）的信息。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    3. 获取数据类型信息

    下表列示常规数据类型编号及其对应类型名称。

    数据类型编号 类型名称
    12 纯文本 / 多行文本 / 电子邮件 / URL
    -7 是 / 无决定
    8 百分比 / 货币 / 小数
    -5 数字 / 自动数字 / 正数
    93 日期

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_DATATYPES

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION DATABASEMETADATA 此参数指定 API 请求要执行的操作。
    ZOHO_METADATA ZOHO_DATATYPES 获取 Zoho Analytics 支持的数据类型列表
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    4. 获取表类型

    下表列示常规表类型。

    实际视图 表类型值
    表 表
    查询表 视图
    图表 / 透视图 / 表格视图 / 摘要视图 / 统计图表 REPORT

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_TABLETYPES

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION DATABASEMETADATA 此参数指定 API 请求要执行的操作。
    ZOHO_METADATA ZOHO_TABLETYPES Zoho Analytics 中的各种可用视图类型
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    响应属性

    在本节中，我们描述了在 DATABASEMETADATA API 中使用的属性的详细说明。

    属性 描述
    IS_DEFAULT/isDefault 指示 Zoho Analytics 工作空间是否设置为默认值。可用于为使用 JDBC 驱动程序加载 Zoho Analytics 工作空间的第三方工具设置默认工作空间。
    TABLE_CAT/tableCat Zoho Analytics 工作空间名称（例如：SalesDB）
    COLUMN_NAME/columnName 表类型视图中的列的名称（例如：Region）
    LITERAL_PREFIX 发现文字值时使用的前缀字符（例如：'45’）
    NULLABLE 如果列可包含空值，那么将为 true，否则为 false。
    MAXSIZE 列的最大大小（例如：20）
    TYPE_NAME 数据类型的 Zoho Analytics 名称（例如：正数）

    Note:XML 响应中的 \N 是指空值

    使用 JDBC 驱动程序获取元数据

    如果要使用 Java 应用程序，那么 Zoho Analytics 会提供 JDBC 驱动程序，它可用于获取所有 Zoho Analytics 元数据信息。有关详细信息，请参阅 JDBC 驱动程序页面。

    WORKSPACE METADATA 中的可能错误代码

    7102、7103、8504、8506、8516、8533

    获取工作空间名称

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBID = 999999999999999;

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void getdbname(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL);
            string result = rc.GetDatabaseName(uri, DBID, null);
            Console.WriteLine(result);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.getdbname(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
        dbid = "999999999999999"
)

func getdatabasename() {
        url := reportclient.GetUserUri(email)
        databasename , err := reportclient.GetDatabaseName(url, dbid)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(databasename)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        getdatabasename()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String authtoken = "************";
    long dbid = 999999999999999;
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void getdbname() throws Exception
    {
        String uri = rc.getURI(email);
        String result =  rc.getDatabaseName(uri,dbid);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.getdbname();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getUserURI($EMAIL_ID);
    $db_id = 999999999999999;
    $database_name = $report_client_request->getDatabaseName($uri, $db_id);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DBID="999999999999999"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def getdatabasename(self,rc):
        uri = rc.getUserURI(self.LOGINEMAILID)
        result = rc.getDatabaseName(uri,self.DBID)
        print result

obj = Sample()
obj.getdatabasename(obj.rc)

    curl -d "ZOHO_ACTION=GETDATABASENAME&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=
         XML&ZOHO_API_VERSION=1.0&authtoken=************&
         DBID=999999999999999"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <response uri="/api/EmailAddress" action="GETDATABASENAME">
    <dbname>Employee</dbname>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "GETDATABASENAME",
        "result":
        {
            "dbname": "Employee"
        }
    }
}

    在给定工作空间 ID 作为输入的情况下，此 API 返回 Zoho Analytics 中的工作空间的名称。工作空间 ID 是与 Zoho Analytics 中创建的每个报告工作空间相关联的唯一标识。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=GETDATABASENAME&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&DBID=999999999999999

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION GETDATABASENAME 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    DBID
    （必需）    		 长数字，例如，9999999999999 Zoho Analytics 在线报告工作空间的 DBID，可从工作空间 URL 获取

    GET WORKSPACE NAME 中的可能错误代码

    7103、7104、8504、8506、8516、8533

    工作空间是否存在

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void isdbexist(IReportClient rc)
        {
            try
            {
                string uri = rc.GetURI(EMAIL);
                bool result = rc.IsDbExist(uri, "Workspace Name", null);
                Console.WriteLine(result);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.isdbexist(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
)

func isdbexist(){
        url := reportclient.GetUserUri(email)
        databasename := "Workspace Name"
        params := map[string]string{}
        result , err := reportclient.IsDbExist(url, databasename, params)
        if(err != nil){
        fmt.Println(err.ErrorMessage)
        fmt.Println(err.ErrorCode)
        fmt.Println(err.Action)
        fmt.Println(err.HttpStatusCode)
        }else{
        fmt.Println(result)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        isdbexist()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void isdbexist() throws Exception
    {
        String uri = rc.getURI(email);
        boolean result = rc.isDbExist(uri, "Workspace Name", null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.isdbexist();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $request->getUserURI($EMAIL_ID);
    $dbname = "<db-name>";
    $result = $request->isDbExist($uri, $dbname);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def isdbexist(self,rc):
    uri = rc.getUserURI(self.LOGINEMAILID)
    dbname = "Workspace Name"
    result = rc.isDbExist(uri,dbname)
    print result

obj = Sample()
obj.isdbexist(obj.rc)

    curl -d "ZOHO_ACTION=ISDBEXIST&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_DB_NAME=Workspace Name"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress" action="ISDBEXIST">
    <result>
        <isdbexist>true</isdbexist>
    </result>
</response>

    样本响应 JSON 格式：

    {
  "response": {
    "uri": "/api/EmailAddress",
    "action": "ISDBEXIST",
    "result": {
      "isdbexist": "true"
    }
  }
}

    “工作空间是否存在 API”用于检查工作空间在 Zoho Analytics 帐户中是否存在。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中检查工作空间。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=ISDBEXIST&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_DB_NAME=Workspace Name

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION ISDBEXIST 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_DB_NAME
    （必需）    		 <Workspacename> 此参数包含工作空间的名称

    IS WORKSPACE EXIST 中的可能错误代码

    8504、8506、8516、8533

    获取工作空间密钥

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void 
(IReportClient RepClient)
        {
            string dbURI = RepClient.GetURI(EMAIL, DBNAME);
            string key = RepClient.GetCopyDBKey(dbURI, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.copyDatabaseKey(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
)

func getcopydbkey() {
    url := reportclient.GetDbUri(email, dbname)
    dbkey , err := reportclient.GetCopyDbKey(url)
    if(err != nil){
        fmt.Println(err.ErrorMessage)
        fmt.Println(err.ErrorCode)
        fmt.Println(err.Action)
        fmt.Println(err.HttpStatusCode)
    }else{
        fmt.Println(dbkey)
    }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        getcopydbkey()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void copydatabasekey() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        String key = rc.getCopyDBKey(uri, null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.copydatabasekey();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $request->getDbURI($EMAIL_ID, $DB_NAME);
    $database_key = $request->getCopyDbKey($uri);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def CopyDatabaseKey(self,rc):
        uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
        result = rc.getCopyDBKey(self.uri)

obj = Sample()
obj.CopyDatabaseKey(obj.rc)

    curl -d "ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="GETCOPYDBKEY">
    <result>
        <copydbkey>************</copydbkey>
    </result>
</response>

    样本响应 JSON 格式：

    {
  "response": {
    "uri": "/api/EmailAddress/WorkspaceName",
    "action": "GETCOPYDBKEY",
    "result": {
      "copydbkey": "************"
    }
  }
}

    “获取工作空间 API”用于获取特定工作空间密钥。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION GETCOPYDBKEY 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    COPY WORKSPACE KEY 中的可能错误代码

    7102、7103、8504、8506、8516、8533

    获取视图名称

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    OBJID = ************;

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void getviewname(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL);
            string result = rc.GetViewName(uri, OBJID, null);
            Console.WriteLine(result);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.getviewname(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
        objid = "************"
)

func getviewname() {
        url := reportclient.GetUserUri(email)
        viewname , err := reportclient.GetViewname(url, objid)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(viewname)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        getviewname()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";

    String authtoken = "************";
    long objid = ************;
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void getviewname() throws Exception
    {
        String uri = rc.getURI(email);
        String result =  rc.getViewName(uri,objid,config);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.getviewname();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getUserURI($EMAIL_ID);
    $objid = ************;
    $view_name = $report_client_request->getViewName($uri, $objid);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    ODBID="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def getviewname(self,rc):
        uri = rc.getUserURI(self.LOGINEMAILID)
        result = rc.getViewName(uri,self.OBJID)
        print result

obj = Sample()
obj.getviewname(obj.rc)

    curl -d "ZOHO_ACTION=GETVIEWNAME&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &OBJID=************"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <response uri="/api/EmailAddress" action="GETVIEWNAME">
    <viewname>Employee Details</viewname>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "GETVIEWNAME",
        "result":
        {
            "viewname": "Employee Details"
        }
    }
}

    在给定视图 ID 作为输入的情况下，此 API 返回 Zoho Analytics 中的视图的名称。视图 ID 是与 Zoho Analytics 中创建的每个视图（表、报告和统计图表）相关联的唯一标识。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=GETVIEWNAME&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&OBJID=************

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION GETVIEWNAME 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    OBJID
    （必需）    		 长数字，例如，9999999999999 可从对应视图 URL 获取的视图 ID。

    GET VIEW NAME 中的可能错误代码

    7104、7106、8504、8506、8516、8533

    获取信息

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void getinfo(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
            var result = rc.GetInfo(uri, null);
            foreach (KeyValuePair<string, long> kvp in result)
            {
                Console.WriteLine(kvp.Key + " " + kvp.Value);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.getinfo(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func getinfo() {
        url := reportclient.GetUri(email, dbname, tbname)
        info , err := reportclient.GetInfo(url)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(info)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        getinfo()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void getinfo() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        Map result =  rc.getInfo(uri,config);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.getinfo();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $report_info = $report_client_request->getInfo($uri);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def getinfo(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        result = rc.getInfo(uri)
        print result

obj = Sample()
obj.getinfo(obj.rc)

    curl -d "ZOHO_ACTION=GETINFO&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName/TableName" action="GETINFO">
    <objid>99999999999999</objid>
    <dbid>88888888888888</dbid>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action": "GETINFO",
        "result":
        {
            "objid": "99999999999999",
            "dbid": "88888888888888"
        }
    }
}

    此 API 返回作为 API 输入提供的对应工作空间和视图名称的工作空间 ID (DBID) 和视图 ID (OBJID)。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=GETINFO&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION GETINFO 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    GET INFO 中的可能错误代码

    7102、7103、7104、8504、8506、8516、8533

    “元数据 API”中的错误代码

    样本错误 XML 格式：

    
<response uri="/api/EmailAddress/WorkspaceName" action="DATABASEMETADATA">
    <error>
        <code>7103</code>
        <message>
        Workspace not found! Please check whether the Workspace exists
        </message>
    </error>
</response>

    样本错误 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName",
        "action": "DATABASEMETADATA",
        "error":
        {
        "code":7103,
        "message": "Workspace not found! Please check whether
                               the Workspace exists"
        }
    }
}

    本节列示“元数据 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。

    错误代码

    错误代码 原因 解决方案
    7102 API 请求 URL 中指定的工作空间名称为空。 检查 API 请求 URL，并提供有效的工作空间名称。
    7103 API URL 中提到的工作空间名称不存在。 检查请求 URL 中的工作空间名称，并提供有效的工作空间名称。
    7104 API 请求 URL 中指定的视图名称不存在。 检查请求 URL 中的视图名称并提供有效的视图名称。
    7106 视图 ID 在工作空间中不存在。 请提供有效 OBJID。
    8504 所需参数不正确或未发送。 请发送带有有效数据的参数。
    8506 所提及参数的已发送次数超过所需次数。 检查响应中提及的额外参数并移除。
    8516 所提及参数中传递了无效值。 对所提及参数提供有效数据。
    8533 URL 中提供的用户电子邮件地址为错误格式。 请提供有效电子邮件地址。

    如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至 support@zohoanalytics.com。Zoho Analytics 团队将回复您并给出最佳可行解决方案。

    共享与协作 API

    本节提供用于共享与协作的 API。您可通过 API 以在进行细粒度控制的情况下将 Zoho Analytics 中创建的视图（报告和统计图表）共享给用户。还可通过 API 管理共享及移除共享。

    共享视图

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void shareview(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME);
            string emails = "user1@zoho.com";
            string views = "Employee";
            Dictionary<string, string> dic = new Dictionary<string, string>();
            dic.Add("ZOHO_READ", "true");
            rc.ShareView(uri, emails, views, dic);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.shareview(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
)

func shareview() {
        url := reportclient.GetDbUri(email, dbname)
        emailids := "user1@zoho.com"
        views := "TableName1,TableName2"
        params := map[string]string{}
        params["ZOHO_READ"] = "true"
        err := reportclient.ShareView(url, emailids, views, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        shareview()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    String emails = "abc@zoho.com";
    String views = "TableName1.TableName2";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void shareview() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        config.put("ZOHO_READ", true);
        rc.shareView(uri,views,emails,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.shareview();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $emails = "user1@zoho.com";
    $views = "viewname1,viewname2";
    $criteria = NULL;
    $premissions = array('ZOHO_READ' => "true");
    $report_client_request->shareView($uri, $emails, $views, $criteria, $permissions);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def shareview(self,rc):
        uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
        permissions = {"ZOHO_READ":"true"}
        rc.shareView(uri,"user1@zoho.com","viewname1",None,permissions)

obj = Sample()
obj.shareview(obj.rc)

    curl -d "ZOHO_ACTION=SHARE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
         ZOHO_API_VERSION=1.0&authtoken=************&
         ZOHO_VIEWS=viewname1,viewname2&ZOHO_EMAILS=abc@zoho.com&ZOHO_READ=true"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="SHARE">
    <result>success</result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName",
        "action": "SHARE",
        "result": "success"
    }
}

    通过 Zoho Analytics 的“共享 API”，您可将 Zoho Analytics 中创建的视图（表/报告/统计图表）共享给用户。“共享 API”还允许您撤销所授予的共享权限。使用 API 之前，建议阅读“共享与协作”文档以更好地了解该 API。

    Note: 可通过再次调用“Share”来更新共享权限（覆盖现有共享权限）。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=SHARE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_VIEWS=NewChart&ZOHO_EMAILS=abc@zoho.com&ZOHO_READ=true

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION SHARE 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    Note:建议在 API URL 中使用 Zoho Analytics 登录电子邮件地址来代替 Zoho 用户名。

    特定于操作的参数

    参数 可能的值 描述 评论
    ZOHO_VIEWS Table1,View1,View2,My View 要共享的视图的列表。可通过在视图间用逗号分隔的方式共享多个视图。
    Note:ZOHO_VIEWS 是以 URL 编码格式编写的。下面给出没有编码的值：
    ZOHO_VIEWS=Table1,View1,View2,My View    		 必备参数
    ZOHO_EMAILS user1@finepick.com, user2@finepick.com 需要与其共享视图的用户电子邮件地址（以逗号分隔值的形式）。
    Note:ZOHO_EMAILS 是以 URL 编码格式编写的。下面给出没有编码的值：
    ZOHO_EMAILS=user1@finepick.com,user2@finepick.com    		 必备参数
    ZOHO_DOMAINNAME
    （仅适用于白标客户）    		 域名 它用于将视图共享给白标客户。 可选

    POST 参数，用于细粒度权限（下面需要至少一个参数）

    参数 允许的值 默认值 描述
    ZOHO_READ true 或 false false 对视图的读访问权
    ZOHO_EXPORT true 或 false false 对视图的导出权限
    ZOHO_VUD true 或 false false 查看图表/透视图/摘要视图中的底层数据的权限
    ZOHO_DRILLDOWN true 或 false false 在图表中向下展开的权限
    ZOHO_ADDROW true 或 false false 在表中添加行的权限
    ZOHO_UPDATEROW true 或 false false 在表中更新行的权限
    ZOHO_DELETEROW true 或 false false 在表中删除行的权限
    ZOHO_DELETEALLROWS true 或 false false 在表中删除所有行的权限
    ZOHO_IMPORT_APPEND true 或 false false 使用 APPEND 选项在表中导入数据的权限
    ZOHO_IMPORT_ADDORUPDATE true 或 false false 使用 ADD 或 UPDATE 选项在表中导入数据（即，附加新行及根据 IMPORT 操作中提供的匹配列更新现有行）的权限
    ZOHO_IMPORT_DELETEALLADD true 或 false false 使用选项在表中导入数据的权限：删除所有现有记录及添加新记录
    ZOHO_SHARE true 或 false false 对用户共享表/视图的权限

    其他参数

    参数 允许的值 默认值 描述 评论
    ZOHO_CRITERIA 过滤条件应使用以下示例中给出的格式指定。它与 SQL 语言中的 WHERE 子句类似。阅读更多 ZOHO_CRITERIA：
    此参数允许您在对用户共享视图时应用过滤条件。共享用户访问报告时，通过过滤所查看数据，将对所共享报告应用所指定条件。
    参阅以下链接以使用 ZOHO_CRITERIA：
    条件
    ZOHO_INHERIT_PARENT_CRITERIA true 或 false false 仅对报告（而不是表）有效。如果为 true，那么在共享时也会考虑其父表的条件
    ZOHO_INVITE_MAIL true 或 false false 共享时是否发送邀请邮件 对于白标客户：
    如果此参数设置为“true”，请在“共享 API”请求中使用白标域 URL 而不是 analyticsapi.zoho.com。
    ZOHO_MAIL_SUBJECT 仅当 ZOHO_INVITE_MAIL 为 true 时必需
    ZOHO_MAIL_MESSAGE
    ZOHO_INVITE_MAIL_CCME true 或 false false 共享时是否将邀请邮件抄送给您 仅当 ZOHO_INVITE_MAIL 为 true 时，此参数才有效

    SHARE VIEWS 中的可能错误代码

    7103、8026、8027、8509、8504、8506、8516、8533

    移除共享

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void removeshare(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME);
            string emails = "user1@zoho.com";
            Dictionary<string, string> dic = new Dictionary<string, string>();
            dic.Add("ZOHO_VIEWS", "Employee");
            rc.RemoveShare(uri, emails,dic);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.removeshare(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
)

func removeshare() {
        url := reportclient.GetDbUri(email, dbname)
        emailids := "user1@zoho.com"
        params := map[string]string{}
        params["ZOHO_ALLVIEWS"] = "true"
        err := reportclient.RemoveShare(url, emailids, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        removeshare()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    String emails = "abc@zoho.com";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void removeshare() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        config.put("ZOHO_ALLVIEWS", true);
        rc.removeShare(uri,emails,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.removeshare();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $emails = "Email Address";
    $permissions = array('ZOHO_ALLVIEWS' => "true");
    $report_client_request->removeShare($uri, $emails, $permissions);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def removeshare(self,rc):
        uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
        params = {"ZOHO_ALLVIEWS":"true"}
        rc.removeShare(uri,"Email Address",params)

obj = Sample()
obj.removeshare(obj.rc)

    curl -d "ZOHO_ACTION=REMOVESHARE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
         ZOHO_API_VERSION=1.0&authtoken=************&
         ZOHO_EMAILS=user1@zoho.com&ZOHO_ALLVIEWS=true"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="REMOVESHARE">
    <result>success</result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName",
        "action": "REMOVESHARE",
        "result": "success"
    }
}

    通过 Zoho Analytics 的“工作空间管理员 API”，您可以添加/移除工作空间管理员。使用 API 之前，建议阅读有关“多个工作空间管理员”的文档以更好地了解该 API。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=REMOVESHARE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=abc@zoho.com&ZOHO_ALLVIEWS=true

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION REMOVESHARE 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数 可能的值 默认值 描述 评论
    ZOHO_VIEWS Table1,View1,View2,My View 需要移除其共享的视图。可使用逗号分隔符传递多个视图。
    Note:ZOHO_VIEWS 是以 URL 编码格式编写的。下面给出没有编码的值：
    ZOHO_VIEWS=Table1,View1,View2,My View    		 任一参数（ZOHO_VIEWS 或 ZOHO_ALLVIEWS）是必需参数。
    ZOHO_ALLVIEWS true 或 false false 如果传递至此参数的值为 true，那么系统将移除对共享给对应用户的所有视图的共享
    （用户是通过参数 ZOHO_EMAILS 中传递的电子邮件地址标识的）    		 任一参数（ZOHO_VIEWS 或 ZOHO_ALLVIEWS）是必需参数。
    ZOHO_EMAILS user1@finepick.com, user2@finepick.com 需要针对所指定视图移除对其的共享的用户电子邮件地址（以逗号分隔值形式）
    Note: ZOHO_EMAILS 是以 URL 编码格式编写的。下面给出没有编码的值：
    ZOHO_EMAILS=user1@finepick.com,user2@finepick.com    		 必备参数
    ZOHO_DOMAINNAME
    （仅适用于白标客户）    		 域名 它用于从白标域中移除共享视图。 可选

    REMOVE SHARE 中的可能错误代码

    7003、7103、8027、8509、8504、8506、8516、8533

    添加工作空间管理员

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void adddbowner(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME);
            string emails = "user1@zoho.com";
            rc.AddDbOwner(uri, emails, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.adddbowner(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
)

func adddbowner() {
        url := reportclient.GetDbUri(email, dbname)
        emailids := "user1@zoho.com"
        params := map[string]string{}
        err := reportclient.AddDbOwner(url, emailids, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        adddbowner()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    String emails = "abc@zoho.com";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void adddbowner() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        rc.addDbOwner(uri,emails,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.adddbowner();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $emails = "user1@zoho.com";
    $report_client_request->addDbOwner($uri, $emails);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def adddbowner(self,rc):
        uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
        rc.addDbOwner(uri,"user1@zoho.com")

obj = Sample()
obj.adddbowner(obj.rc)

    curl -d "ZOHO_ACTION=ADDDBOWNER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_EMAILS=EmailAddress1"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="ADDDBOWNER">
    <result>success</result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName",
        "action": "ADDDBOWNER",
        "result": "success"
    }
}

    此 API 用于对特定工作空间添加工作空间管理员。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=ADDDBOWNER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION ADDDBOWNER 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数 可能的值 描述 评论
    ZOHO_EMAILS user1@finepick.com, user2@finepick.com 需要针对所指定视图移除对其的共享的用户电子邮件地址（以逗号分隔值形式）
    Note: ZOHO_EMAILS 是以 URL 编码格式编写的。下面给出没有编码的值：
    ZOHO_EMAILS=user1@finepick.com,user2@finepick.com    		 必备参数
    ZOHO_DOMAINNAME
    （仅适用于白标客户）    		 域名 它用于向白标域添加工作空间管理员。 可选

    其他参数

    参数 允许的值 默认值 描述 评论
    ZOHO_INVITE_MAIL true 或 false false 共享时是否发送邀请邮件 对于白标客户：
    如果此参数设置为“true”，请在“共享 API”请求中使用白标域 URL 而不是 analyticsapi.zoho.com。
    ZOHO_MAIL_SUBJECT 仅当 ZOHO_INVITE_MAIL 为 true 时必需
    ZOHO_MAIL_MESSAGE

    ADD WORKSPACE ADMIN 中的可能错误代码

    7103、8504、8506、8509、8516、8533

    移除工作空间管理员

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void removedbowner(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME);
            string emails = "user1@zoho..com";
            rc.RemoveDbOwner(uri, emails, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.removedbowner(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
)

func removedbowner() {
        url := reportclient.GetDbUri(email, dbname)
        emailids := "user1@zoho.com"
        params := map[string]string{}
        err := reportclient.RemoveDbOwner(url, emailids, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        removedbowner()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    String emails = "abc@zoho.com";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void removedbowner() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        rc.removeDbOwner(uri,emails,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.removedbowner();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $emails = "user1@zoho.com";
    $report_client_request->removeDbOwner($uri, $emails);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def removedbowner(self,rc):
        uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
        rc.removeDbOwner(uri,"user1@zoho.com")

obj = Sample()
obj.removedbowner(obj.rc)

    curl -d "ZOHO_ACTION=REMOVEDBOWNER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_EMAILS=EmailAddress1"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="REMOVEDBOWNER">
    <result>success</result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "/api/EmailAddress/WorkspaceName",
        "action": "REMOVEDBOWNER",
        "result": "success"
    }
}

    此 API 用于从特定工作空间中移除工作空间管理员。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=REMOVEDBOWNER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION REMOVEDBOWNER 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数 可能的值 描述 评论
    ZOHO_EMAILS user1@finepick.com, user2@finepick.com 需要针对所指定视图移除对其的共享的用户电子邮件地址（以逗号分隔值形式）
    Note: ZOHO_EMAILS 是以 URL 编码格式编写的。下面给出没有编码的值：
    ZOHO_EMAILS=user1@finepick.com,user2@finepick.com    		 必备参数
    ZOHO_DOMAINNAME
    （仅适用于白标客户）    		 域名 它用于从白标域中移除工作空间管理员。 可选

    其他参数

    参数 允许的值 默认值 描述 评论
    ZOHO_INVITE_MAIL true 或 false false 共享时是否发送邀请邮件 对于白标客户：
    如果此参数设置为“true”，请在“共享 API”请求中使用白标域 URL 而不是 analyticsapi.zoho.com。
    ZOHO_MAIL_SUBJECT 仅当 ZOHO_INVITE_MAIL 为 true 时必需
    ZOHO_MAIL_MESSAGE

    REMOVE WORKSPACE ADMIN 中的可能错误代码

    7103、8504、8506、8509、8516、8533

    获取共享信息

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void getshareinfo(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL, DBNAME);
            var result = rc.GetShareInfo(uri, null);
            var list = result.GetGroupMembers();
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.getshareinfo(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        authtoken = "************"
)

func getshareinfo() {
        url := reportclient.GetDbUri(email, dbname)
        shareinfo , err := reportclient.GetShareInfo(url)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(shareinfo.GroupMembers)
                fmt.Println(shareinfo.UserInfo)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        getshareinfo()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void shareinfo() throws Exception
    {
        String uri = rc.getURI(email,dbname);
        Object shareinfoobj = rc.getShareInfo(uri,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.shareinfo();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
    $report_client_response = $report_client_request->getShareInfo($uri);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def getshareinfo(self,rc):
        uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
        result = rc.getShareInfo(uri)
        print result.sharedUsers

obj = Sample()
obj.getshareinfo(obj.rc)

    curl -d "ZOHO_ACTION=GETSHAREINFO&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="GETSHAREINFO">
  <result>
      <usershareinfo>
        <shareinfo>
            <email>user1@mydomain.com</email>
                <permissions>
                    <perminfo viewname="Table1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gttrue&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user4@mydomain.com</email>
                <permissions>
                    <perminfo viewname="Table1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gttrue&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user215@mydomain.com</email>
                <permissions>
                    <perminfo viewname="finepick1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>userlf12@mydomain.com</email>
                <permissions>
                    <perminfo viewname="Parent" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user33@mydomain.com</email>
                <permissions>
                    <perminfo viewname="Parent" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                    <perminfo viewname="sss" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                    <perminfo viewname="Table1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user1@mydomain.com</email>
                <permissions>
                    <perminfo viewname="finepick1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user115@mydomain.com</email>
                <permissions>
                    <perminfo viewname="Table1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gttrue&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user11@mydomain.com</email>
                <permissions>
                    <perminfo viewname="grp_pv1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gttrue&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user214@mydomain.com</email>
                <permissions>
                    <perminfo viewname="finepick1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user104@mydomain.com</email>
                <permissions>
                    <perminfo viewname="Table1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gttrue&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user10@mydomain.com</email>
                <permissions>
                    <perminfo viewname="Table2" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
        <shareinfo>
            <email>user101@mydomain.com</email>
                <permissions>
                    <perminfo viewname="Table1" sharedby="user@mydomain.com">
                        <permission>
                            <read&gttrue&lt;/read>
                            <export&gtfalse&lt;/export>
                            <vud&gtfalse&lt;/vud>
                            <addrow&gtfalse&lt;/addrow>
                            <updaterow&gtfalse&lt;/updaterow>
                            <deleterow&gtfalse&lt;/deleterow>
                            <deleteallrows&gtfalse&lt;/deleteallrows>
                            <appendimport&gtfalse&lt;/appendimport>
                            <updateimport&gtfalse&lt;/updateimport>
                            <truncateimport&gtfalse&lt;/truncateimport>
                            <deleteupdateaddimport&gtfalse&lt;/deleteupdateaddimport>
                            <share&gtfalse&lt;/share>
                        </permission>
                    </perminfo>
                </permissions>
        </shareinfo>
    </usershareinfo>
    <publicshareinfo>
    </publicshareinfo>
    <privatelinkshareinfo>
    </privatelinkshareinfo>
    <groupshareinfo>
        <groupmembers>
            <member>user10@mydomain.com</member>
            <member>user1@mydomain.com</member>
        </groupmembers>
    </groupshareinfo>
    <dbownershareinfo>
        <dbowners>
            <member>user13@mydomain.com</member>
            <member>user1@mydomain.com</member>
        </dbowners>
    </dbownershareinfo>
  </result>
</response>

    样本响应 JSON 格式：

    {
   "response":{
      "uri":"\/api\/EmailAddress\/WorkspaceName",
      "action":"GETSHAREINFO",
      "result":{
         "usershareinfo":[
            {
               "shareinfo":{
                  "email":"user1@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"Table1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"true",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user4@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"Table1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"true",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user215@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"finepick1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"userlf12@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"Parent",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user33@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"Parent",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     },
                     {
                        "perminfo":{
                           "viewname":"sss",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     },
                     {
                        "perminfo":{
                           "viewname":"Table1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user1@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"finepick1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user115@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"Table1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"true",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user11@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"grp_pv1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"true",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user214@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"finepick1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user104@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"Table1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"true",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user10@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"Table2",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            },
            {
               "shareinfo":{
                  "email":"user101@mydomain.com",
                  "permissions":[
                     {
                        "perminfo":{
                           "viewname":"Table1",
                           "sharedby":"user@mydomain.com",
                           "permission":{
                              "read":"true",
                              "export":"false",
                              "vud":"false",
                              "addrow":"true",
                              "updaterow":"false",
                              "deleterow":"false",
                              "deleteallrows":"false",
                              "appendimport":"false",
                              "updateimport":"false",
                              "truncateimport":"false",
                              "deleteupdateaddimport":"false",
                              "share":"false"
                           }
                        }
                     }
                  ]
               }
            }
         ],
         "publicshareinfo":{

         },
         "privatelinkshareinfo":{

         },
         "groupshareinfo":{
            "groupmembers":[
               "user10@mydomain.com",
               "user1@mydomain.com"
            ]
         },
         "dbownershareinfo":{
            "dbowners":[
               "user13@mydomain.com",
               "user1@mydomain.com"
            ]
         }
      }
   }
}

    “获取共享信息 API”用于获取工作空间的所有共享信息。只有该工作空间的管理员（该工作空间的创建者）才能使用此 API。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=GETSHAREINFO&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION GETSHAREINFO 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    GET SHARE INFO 中的可能错误代码

    7103、7301、8504、8506、8516、8533

    “共享 API”中的错误代码

    样本错误 XML 格式：

    
<response uri="/api/EmailAddress/WorkspaceName" action="GETVIEWURL">
    <error>
        <code>7103</code>
        <message>
        Workspace not found! Please check whether the Workspace exists
        </message>
    </error>
</response>

    样本错误 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName",
        "action": "GETVIEWURL",
        "error":
        {
        "code":7103,
        "message": "Workspace not found! Please check whether
                               the Workspace exists"
        }
    }
}

    本节列示“共享 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。

    错误代码

    错误代码 原因 解决方案
    7003 请求中缺少必需参数。 发送与该特定操作相关的所有必需参数。
    7103 API URL 中提到的工作空间名称不存在。 请提供现有工作空间名称以获取共享详细信息。
    7301 您（您的全名）无权执行此操作。只有工作空间管理员才具有此权限。 请提供该工作空间的管理员或所有者的认证令牌。
    8026 缺少权限参数。 至少需要下列其中一个参数：[ZOHO_READ、ZOHO_EXPORT、ZOHO_VUD、ZOHO_ADDROW、ZOHO_UPDATEROW、ZOHO_DELETEROW、ZOHO_DELETEALLROWS、ZOHO_IMPORT_APPEND、ZOHO_IMPORT_ADDORUPDATE、ZOHO_IMPORT_DELETEALLADD、ZOHO_IMPORT_DELETEUPDATEADD、ZOHO_SHARE、ZOHO_VUD_SELCOL 和 ZOHO_DRILLDOWN]。
    8027 找不到所提及的视图/工作空间。 请提供有效视图/工作空间名称。
    8504 所需参数不正确或未发送。 请发送带有有效数据的参数。
    8506 所提及参数的已发送次数超过所需次数。 检查响应中提及的额外参数并移除。
    8509 ZOHO_EMAILS 参数中提供的电子邮件 ID 不正确或未使用电子邮件 ID 格式。 检查该参数中传递的电子邮件地址并提供正确电子邮件地址。
    8516 所提及参数中传递了无效值。 对所提及参数提供有效数据。
    8533 URL 中提供的用户电子邮件地址为错误格式。 请提供有效电子邮件地址。

    如果遇到任何其他错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至 support@zohoanalytics.com。Zoho Analytics 团队会尽管回复您并给出最佳可行解决方案。

    嵌入 API

    通过此 API，您可通过程序将 Zoho Analytics 中创建的嵌入报告和统计图表嵌入至网页/应用程序。这为开发人员提供了无缝创建将嵌入其网站和应用程序中的动态报告内容的绝佳机会。

    获取视图 URL

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void getviewurl(IReportClient rc)
        {
            string uri = rc.GetURI(EMAIL,DBNAME,TBNAME);
            string result = rc.GetViewUrl(uri, null);
            Console.WriteLine(result);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.getviewurl(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func getviewurl() {
        url := reportclient.GetUri(email, dbname, tbname)
        viewurl , err := reportclient.GetViewUrl(url)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(viewurl)
        }

}

func main() {
        reportclient.SetAuthToken(authtoken)
        getviewurl()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void getviewurl() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        String result =  rc.getViewURL(uri,config);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.getviewurl();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $view_url = $report_client_request->getViewUrl($uri);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def getviewurl(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        result = rc.getViewUrl(uri)
        print result

obj = Sample()
obj.getviewurl(obj.rc)

    curl -d "ZOHO_ACTION=GETVIEWURL&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName/TableName" action="GETVIEWURL">
    <result>
        <viewurl>
            https://analytics.zoho.com/ZDBDataSheetView.cc?&
            OBJID=9999999999999&STANDALONE=true&REMTOOLBAR=true&
            ZDB_THEME_NAME=blue
        </viewurl>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action": "GETVIEWURL",
        "result":
        {
            "viewurl": "https://analytics.zoho.com/ZDBDataSheetView.cc?&
                      OBJID=9999999999999&STANDALONE=true&REMTOOLBAR=true&
                      ZDB_THEME_NAME=blue"
        }
    }
}

    此 API 返回用于访问所提及视图的 URL。您需要提供工作空间名称和视图名称作为 API 的输入。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=GETVIEWURL&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION GETVIEWURL 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    GET VIEW URL 中的可能错误代码

    7103、7138、8504、8506、8516、8533

    获取嵌入 URL（仅适用于白标客户）

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";
    DBNAME = "Workspace Name";
    TBNAME = "Table Name";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void getEmbedURL(IReportClient RepClient)
        {
            string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
            string result = RepClient.GetEmbedURL(tableURI, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.getEmbedURL(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        dbname = "Workspace Name"
        tbname = "Table Name"
        authtoken = "************"
)

func getembedurl() {
        url := reportclient.GetUri(email, dbname, tbname)
        params := map[string]string{}
        embedurl , err := reportclient.GetEmbedUrl(url, params)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println(embedurl)
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        getembedurl()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String dbname = "Workspace Name";
    String tbname = "Table Name";
    String authtoken = "************";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void getembedurl() throws Exception
    {
        String uri = rc.getURI(email,dbname,tbname);
        String result =  rc.getEmbedURL(uri,config);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.getembedurl();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $DB_NAME = "Workspace Name";
    $TABLE_NAME = "Table Name";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
    $criteria = "Department"='Finance';
    $embed_url = $report_client_request->getEmbedURL($uri ,$criteria);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    DATABASENAME="Workspace Name"
    TABLENAME="Table Name"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def getembedurl(self,rc):
        uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
        result = rc.getEmbedUrl(uri)
        print result

obj = Sample()
obj.getembedurl(obj.rc)

    curl -d "ZOHO_ACTION=GETEMBEDURL&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************"
         https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName

    样本响应 XML 格式：

    <response uri="/api/EmailAddress/WorkspaceName/TableName" action="GETEMBEDURL">
    <result>
        <embedurl>https://analytics.zoho.com/ZDBDataSheetView.cc?&
              OBJID=100000000000026025&REMTOOLBAR=>true&FS=OS
              &RSCONFIG=Ksp6SkShM5/PySm0q3lMQCeqwqe234423qe3BGQC4wp+YS6ahHG8e1j
              035yQrpZwAZdq7I
        </embedurl>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
        "action":"GETEMBEDURL",
        "result": {"embedUrl":"https://analytics.zoho.com/ZDBDataSheetView.cc?&
            OBJID=100000000000026025&REMTOOLBAR=true&FS=OS
            &RSCONFIG=Ksp6SkShM5/PySm0q3lMQCeqwqe234423qe3BGQC4wp+YS6ahHG8e1j
            035yQrpZwAZdq7I"}
    }
}

    “获取嵌入 URL API”用于获取特定表/视图的嵌入 URL。此 API 仅对白标管理员可用。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=GETEMBEDURL&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION GETEMBEDURL 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    URL 参数

    参数 可能的值 描述
    ZOHO_CUSTOMDOMAIN
    （可选）    		 true/false 默认值为 false。
    True - 这将返回嵌入 URL 以及您的域地址。
    False - 这将返回嵌入 URL 以及 zoho 域地址。
    ZOHO_CRITERIA
    （可选）    		 条件 如果未发送该参数，那么所有行将可见。如果已发送条件，那么只有与该条件相匹配的行才可见。
    ZOHO_VUD_PERMISSION
    （可选）    		 true/false 默认值为 false。
    如果为 true，那么该视图有权查看底层数据。
    如果为 false，那么该视图无权查看底层数据。
    ZOHO_INCLUDE_TOOLBAR
    （可选）    		 true/false 默认值为 false。
    如果为 true，那么工具栏在嵌入方式下可见。
    如果为 false，那么所有工具栏在嵌入方式下不可见。
    ZOHO_VALIDITY_PERIOD
    （可选）    		 <number> 控制嵌入 URL 的有效期。
    默认值为 3600 秒（1 小时）。
    此值以秒为单位。
    ZOHO_THEME_COLOR
    （可选）    		 blue/brown 主题颜色。
    默认值为 blue
    ZOHO_DATATYPE_SYMBOL
    （可选）    		 true/false 控制是否在表列中显示数据类型符号。
    默认值为 false
    ZOHO_SEARCH_BOX
    （可选）    		 true/false 控制是否在表中显示搜索框
    ZOHO_IS_SECURE
    （可选）    		 true/false 控制是否以安全方式访问 URL（http 或 https）
    ZOHO_LEGEND_POSITION
    （可选）
  • RIGHT
  • LEFT
  • TOPLEFT
  • TOPRIGHT
  • TOPCENTER
  • BOTTOMLEFT
  • BOTTOMRIGHT
  • BOTTOMCENTER
  • NONE
    		•  控制在图注上的显示位置
    ZOHO_EXPORT_PERMISSION
    （可选）    		 true/false 默认值为 false。
    如果设置为 true，那么该视图有权导出数据。
    如果设置为 false，那么该视图无权导出数据。

    GET EMBED URL 中的可能错误代码

    7103、7138、8023、8504、8506、8516、8533

    “嵌入 API”中的错误代码

    样本错误 XML 格式：

    
<response uri="/api/EmailAddress/Workspacename/TableName" action="GETVIEWURL">
    <error>
        <code>7103</code>
        <message>
        Workspace not found! Please check whether the Workspace exists
        </message>
    </error>
</response>

    样本错误 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress\/WorkspaceName",
        "action": "GETVIEWURL",
        "error":
        {
        "code":7103,
        "message": "Workspace not found! Please check whether
                               the Workspace exists"
        }
    }
}

    本节列示“嵌入 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。

    错误代码

    错误代码 原因 解决方案
    7103 API URL 中提到的工作空间名称不存在。 检查请求 URL 中的工作空间名称，并提供有效的工作空间名称。
    7138 API 请求 URL 中指定的视图名称不存在。 检查请求 URL 中的视图名称并提供有效的视图名称。
    8023 您无权执行此操作。 请联系我们的支持团队。
    8504 所需参数不正确或未发送。 请发送带有有效数据的参数。
    8506 所提及参数的已发送次数超过所需次数。 检查响应中提及的额外参数并移除。
    8516 所提及参数中传递了无效值。 对所提及参数提供有效数据。
    8533 URL 中提供的用户电子邮件地址为错误格式。 请提供有效电子邮件地址。

    如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至 support@zohoanalytics.com。Zoho Analytics 团队将回复您并给出最佳可行解决方案。

    用户管理 API

    本节列示用于管理 Zoho Analytics 管理员帐户中的用户的“用户管理 API”。

    “管理用户 API”用于在 Zoho Analytics 帐户中添加/删除/激活/停用用户。此 API 只能由 Zoho Analytics 帐户的管理员调用，以在其帐户中添加/激活/停用用户。

    Note: 这些 API 不能用于在 Zoho 中创建用户帐户。这只是为了将现有的 Zoho 用户与管理员持有的 Zoho Analytics 帐户相关联。

    获取用户

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void getusers(IReportClient rc)
        {
            try
            {
                string uri = rc.GetURI(EMAIL);
                var result = rc.GetUsers(uri, null);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.getusers(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
)

func getusers(){
    url := reportclient.GetUserUri(email)
    params := map[string]string{}
    result , err := reportclient.GetUsers(url, params)
    if(err != nil){
        fmt.Println(err.ErrorMessage)
        fmt.Println(err.ErrorCode)
        fmt.Println(err.Action)
        fmt.Println(err.HttpStatusCode)
    }else{
        fmt.Println(result)
    }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        getusers()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String authtoken = "************";

    private ReportClient rc = new ReportClient(authtoken);

    public void getusers() throws Exception
    {
        String uri = rc.getURI(email);
        ArrayList resp = rc.getUsers(uri, null);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.getusers();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $request->getUserURI($EMAIL_ID);
    $result = $request->getUsers($uri);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def getusers(self,rc):
        uri = rc.getUserURI(self.LOGINEMAILID)
        result = rc.getUsers(uri)
        print result

obj = Sample()
obj.getusers(obj.rc)

    curl -d "ZOHO_ACTION=GETUSERS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/Email Address" action="GETUSERS">
    <result>
        <user emailId="user+1@zoho.com" status="true" role="User" > </user>
        <user emailId="user+2@zoho.com" status="true" role="workspace Admin" > </user>
        <user emailId="user+3@zoho.com" status="true" role="Admin"> </user>
    </result>
</response>

    样本响应 JSON 格式：

    {
  "response": {
    "uri": "/api/Email Address",
    "action": "GETUSERS",
    "result": [
      {
        "emailId": "user+1@zoho.com",
        "status": true,
        "role": "User"
      },
      {
        "emailId": "user+2@zoho.com",
        "status": true,
        "role": "Workspace Admin"
      },
      {
        "emailId": "user+3@zoho.com",
        "status": true,
        "role": "Admin"
      }
    ]
  }
}

    “获取用户 API”用于获取 Zoho Analytics 帐户中的用户。只有帐户管理员和工作空间管理员才能使用此 API 获取 Zoho Analytics 帐户中的用户列表。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=GETUSERS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************

    常规参数

    参数名称 可能的值 描述
    ZOHO_ACTION GETUSERS 此参数指定 API 请求要执行的操作。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    GETUSERS 中的可能错误代码

    8504、8506、8516、8533

    添加用户

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void addUser(IReportClient RepClient)
        {
            string userURI = RepClient.GetURI(EMAIL);
            string emailIds = "user1@zoho.com";
            RepClient.AddUser(userURI, emailIds, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.addUser(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
)

func adduser() {
        url := reportclient.GetUserUri(email)
        emailids := "user1@zoho.com"
        err := reportclient.AddUser(url, emailids)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        adduser()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String authtoken = "************";
    String emails = "abc@zoho.com";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void adduser() throws Exception
    {
        String uri = rc.getURI(email);
        rc.addUser(uri,emails,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.adduser();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "EmailAddress";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getUserURI($EMAIL_ID);
    $emails = "user1@yourdomain.com,user2@yourdomain.com";
    $report_client_request->addUser($uri, $emails);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="EmailAddress"
    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def AddUser(self,rc):
        uri = rc.getUserURI(self.LOGINEMAILID)
        emailIds = "user1@zoho.com"
        rc.addUser(uri,emailIds)

obj = Sample()
obj.AddUser(obj.rc)

    curl -d "ZOHO_ACTION=ADDUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_EMAILS=EmailAddress1,EmailAddress2"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <response uri="/api/EmailAddress" action="ADDUSER">
    <result>
        <message>User(s) added successfully</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "ADDUSER",
        "result":
        {
            "message": "User(s) added successfully"
        }
    }
}

    可使用此 API 向 Zoho Analytics 帐户添加用户（只要您是管理员）。默认情况下，用户添加时为“活动状态”，并且帐户中的活动用户数将相应增加。如果您的帐户已超过允许的用户数限制，那么新添加的用户将被设置为“已停用”。系统会触发向新添加的用户发送邀请邮件的操作。

    Note: 此 API 仅用于向您（管理员）的 Zoho Analytics 帐户添加用户。此 API 不会在Zoho 中创建用户帐户。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=ADDUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1,EmailAddress2

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION ADDUSER 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_EMAILS 用户电子邮件 ID 此参数包含要在您（管理员）的 Zoho Analytics 帐户中添加的用户的电子邮件地址。
    电子邮件地址间应使用逗号分隔。
    Ex:ZOHO_EMAILS=user1@yourdomain.com,user2@yourdomain.com
    ZOHO_DOMAINNAME
    （仅适用于白标客户）    		 域名 它用于向白标域添加用户。

    ADD USER 中的可能错误代码

    6021、8504、8506、8509、8516、8533

    移除用户

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void removeUser(IReportClient RepClient)
        {
            string userURI = RepClient.GetURI(EMAIL);
            string emailIds = "user1@zoho.com";
            RepClient.RemoveUser(userURI, emailIds, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.removeUser(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
)

func removeuser() {
        url := reportclient.GetUserUri(email)
        emailids := "user1@zoho.com"
        err := reportclient.RemoveUser(url, emailids)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        removeuser()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String authtoken = "************";
    String emails = "abc@zoho.com";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void removeuser() throws Exception
    {
        String uri = rc.getURI(email);
        rc.removeUser(uri,emails,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.removeuser();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getUserURI($EMAIL_ID);
    $emails = "user1@yourdomain.com,user2@yourdomain.com";
    $report_client_request->removeUser($uri, $emails);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def RemoveUser(self,rc):
        uri = rc.getUserURI(self.LOGINEMAILID)
        emailIds = "user1@zoho.com"
        rc.removeUser(uri,emailIds)

obj = Sample()
obj.RemoveUser(obj.rc)

    curl -d "ZOHO_ACTION=REMOVEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_EMAILS=EmailAddress1"
         https://analyticsapi.zoho.com/api/Email Address

    样本响应 XML 格式：

    <response uri="/api/Email Address" action="REMOVEUSER">
    <result>
        <message>User(s) removed successfully</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "REMOVEUSER",
        "result":
        {
            "message": "User(s) removed successfully"
        }
    }
}

    此 API 用于从管理员的 Zoho Analytics 帐户中删除用户。如果移除/删除活动用户，那么与该帐户关联的用户数将减少。下面是用法详细信息。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=REMOVEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=Email Address

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION REMOVEUSER 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_EMAILS 用户电子邮件 ID 此参数包含要从 Zoho Analytics 帐户中删除的用户的电子邮件地址。
    电子邮件地址间应使用逗号分隔。
    Ex:- ZOHO_EMAILS=user1@yourdomain.com,user2@yourdomain.com。
    请注意，从 Zoho Analytics 帐户中移除用户不会从 Zoho 中移除该用户。这只会从管理员的 Zoho Analytics 帐户中移除该用户。
    ZOHO_DOMAINNAME
    （仅适用于白标客户）    		 域名 它用于从白标域中移除用户。

    REMOVE USER 中的可能错误代码

    8504、8506、8509、8516、8533

    活跃用户

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：

    using ZReports;

namespace Test
{
    AUTHTOKEN = "************";
    EMAIL = "Email Address";

    class Program
    {
        public IReportClient getClient()
        {
            IReportClient RepClient = new ReportClient(AUTHTOKEN);
            return RepClient;
        }

        public void activateUser(IReportClient RepClient)
        {
            string userURI = RepClient.GetURI(EMAIL);
            string emailIds = "user1@zoho.com";
            RepClient.ActivateUser(userURI, emailIds, null);
        }

        static void Main(string[] args)
        {
            Program obj = new Program();
            IReportClient rc = obj.getClient();
            obj.activateUser(rc);
        }
    }
}

    package main

import (
        "fmt"
        "zoho/pkg/reportclient"

)

var(
        email = "Email Address"
        authtoken = "************"
)

func activateuser() {
        url := reportclient.GetUserUri(email)
        emailids := "user1@zoho.com"
        err := reportclient.ActivateUser(url, emailids)
        if(err != nil){
                fmt.Println(err.ErrorMessage)
                fmt.Println(err.ErrorCode)
                fmt.Println(err.Action)
                fmt.Println(err.HttpStatusCode)
        }else{
                fmt.Println("Success")
        }
}

func main() {
        reportclient.SetAuthToken(authtoken)
        activateuser()
}

    import com.adventnet.zoho.client.report.*;

public class Sample
{
    String email = "Email Address";
    String authtoken = "************";
    String emails = "abc@zoho.com";
    Map config = new HashMap();

    private ReportClient rc = new ReportClient(authtoken);

    public void activateuser() throws Exception
    {
        String uri = rc.getURI(email);
        rc.activateUser(uri,emails,config);
    }

    public static void main(String[] args) throws Exception
    {
        Sample obj = new Sample();
        obj.activateuser();
    }
}

    <?php
    require 'ReportClient.php';

    $EMAIL_ID = "Email Address";
    $AUTHTOKEN = "************";

    $report_client_request = new ReportClient($AUTHTOKEN);

    $uri = $report_client_request->getUserURI($EMAIL_ID);
    $emails = "user1@yourdomain.com,user2@yourdomain.com";
    $report_client_request->activateUser($uri, $emails);
?>

    from __future__ import with_statement
from ReportClient import ReportClient
import sys

class Sample:

    LOGINEMAILID="Email Address"
    AUTHTOKEN="************"
    rc = None
    rc = ReportClient(self.AUTHTOKEN)

    def ActivateUser(self,rc):
        uri = rc.getUserURI(self.LOGINEMAILID)
        emailIds = "user1@zoho.com"
        rc.activateUser(uri,emailIds)

obj = Sample()
obj.ActivateUser(obj.rc)

    curl -d "ZOHO_ACTION=ACTIVATEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
         &ZOHO_API_VERSION=1.0&authtoken=************
         &ZOHO_EMAILS=Email Address"
         https://analyticsapi.zoho.com/api/EmailAddress

    样本响应 XML 格式：

    <response uri="/api/abc@zoho.com" action="ACTIVATEUSER">
    <result>
        <message>User(s) activated successfully</message>
    </result>
</response>

    样本响应 JSON 格式：

    {
    "response":
    {
        "uri": "\/api\/EmailAddress",
        "action": "ACTIVATEUSER",
        "result":
        {
            "message": "User(s) activated successfully"
        }
    }
}

    可使用“激活用户 API”来激活用户。激活用户后，他/她将包含在活动用户总数内。如果达到该帐户的可用用户数限制，那么此 API 无法激活该用户。

    http 请求

    https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=ACTIVATEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1,EmailAddress2

    常规参数

    参数 可能的值 描述
    ZOHO_ACTION ACTIVATEUSER 此参数指定 API 请求要执行的操作。
    Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
    ZOHO_OUTPUT_FORMAT XML/JSON 此参数指定响应的输出格式。
    ZOHO_ERROR_FORMAT XML/JSON 如果尝试处理请求时发生错误，请指定响应的输出格式。
    authtoken 用户身份验证令牌 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。
    ZOHO_API_VERSION 1.0 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。

    特定于操作的参数

    参数名称 可能的值 描述
    ZOHO_EMAILS 用户电子邮件 ID 此参数包含要在管理员的 Zoho Analytics 帐户中激活的用户的电子邮件地址。
    电子邮件地址间应使用逗号分隔。
    Ex:- ZOHO_EMAILS=user1@yourdomain.com,user2@yourdomain.com
    ZOHO_DOMAINNAME
    （仅适用于白标客户）    		 域名 它用于在白标域中激活用户。

    ACTIVATE USER 中的可能错误代码

    6021、8504、8506、8509、8516、8533

    停用用户

    下载客户端库： C# | GO | JAVA | PHP | PYTHON



    样本请求：