FetchXml生成及相应的语法

一、Fetch Xml语法结构

 

<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>//默认信息

//相当于sql里面的 from 表名

<entity name="实体名">//相当于表名

//相当于sql里面的 select 字段名

<attribute name="字段名" />//字段

//相当于sql里面的where条件

<filter type='and'>   //条件  and  = ”且“   or = “或”

          <condition attribute='字段名' operator='eq' value='0' />//查询这个字段=0的信息

 </filter>

</entity>

</fetch>

operator常用的值有：  

eq (相等)，ne(不等)，lt(小于)，gt(大于)，le(小于或等于)，ge(大于或等于)，null（为空），not-null（不为空），in（包含），not-in（不包含），on-or-before（等于或早于这个日期）on-or-after（晚于或等于这个日期），等

 

 

 

 

 

 

聚合查询

使用聚合函数查询：

<fetch version='1.0' output-format='xml - platform' mapping='logical' distinct='false' aggregate='true'> //红色的这个属性是最重要的的  一定要加上   （允许使用聚合函数）

 <entity name = 'new_electric_recording' >

           <attribute name = 'new_contractid' alias = 'new_contractid' groupby = 'true' />

           <attribute name = 'new_accountid' alias = 'new_accountid'  groupby = 'true' />

           <attribute name = 'new_cabinetcode' alias = 'new_cabinetcode'  groupby = 'true' />

           <attribute name = 'new_actualelectric' alias = 'estimatedvalue_avg' aggregate = 'avg' />

   <filter type = 'and' >

     <filter type = 'and' >

       <condition attribute = 'new_begdate' operator= 'on-or-before' value = '2020-1-8' />

       <condition attribute = 'new_begdate' operator= 'on-or-after' value = '2019-1-9' />

     </filter >

   </filter >

 </entity >

</fetch >

如果要求某一个字段的平均值   给该字段上面  加  aggregate = 'avg'  

如果要根据某一字段进行分组   给该字段上面  加  groupby = 'true'  

 

aggregate常用的值：

count（求数量），sum（求和），avg（求平均），min（最小值），max（最大值）

 

特别提示：FetchXML 包括使您能够计算总和、平均值、最小值、最大值和计数的分组和聚合函数。

在查询中只能指定一个 aggregate 属性，而且不能使用 distinct 关键字。要创建的聚合的属性，

请设置关键字aggregate到true，然后指定有效的实体名称， 属性名称，和别名 （变量名）。

同时必须指定要执行的聚合的类型。

 

 

二、fetch xml生成方式

在Dynamics Crm中fetchXml是经常使用到的，用于查询实体数据，但这玩意不需要手写，dynamic支持生成及下载。

 

 

这里就演示一个链接查询

 

 

 

 

link-entity是链接字段

js脚本（此方法返回的是满足条件的数据集合）

前端调用

 function GetParts(condition) {
            var list = [];
            var fetchXml =
                'mcs_spmrepackages?fetchXml=<fetch version="1.0" output-format="xml-platform" mapping="logical" distinct="false">' +
                '<entity name="mcs_spmrepackage">' +
                '<attribute name="mcs_name" />' +
                '<attribute name="mcs_shelvetime" />' +
                '<attribute name="mcs_comments" />' +
                '<attribute name="mcs_onecode" />' +
                '<attribute name="mcs_quantity" />' +
                '<attribute name="mcs_onstaff" />' +
                '<attribute name="mcs_spmrepackageid" />' +
                '<order attribute="mcs_name" descending="true" />' +
                '<filter type="and">' +
                '<filter type="or">' +
                条件 +
                '</filter>' +
                '</filter>' +
                '<link-entity name="mcs_parts" from="mcs_partsid" to="mcs_partid" visible="false" link-type="outer" alias="a_72435aebfd3ae911a8238f70019cae31">' +
                '<attribute name="mcs_name" />' +
                '</link-entity>' +
                '<link-entity name="mcs_spmreceive" from="mcs_spmreceiveid" to="mcs_spmreceiveid" alias="aa">' +
                '<attribute name="mcs_spmwarehouseid" />' +
                '</link-entity>' +
                '</entity>' +
                '</fetch>';
            CRM.Common.querySync(fetchXml,
                true,
                function (results) {
                    if (results.value && results.value.length > 0) {
                        list = results.value;

                    }
                },
                function (req) {
                });
            return list;//json格式的数据
        }

 

 

后端调用

string xml = $@"<fetch version='1.0' output-format='xml-platform' count='10' mapping='logical' distinct='true' >
                                    <entity name='mcs_tc_order' >
                                        <attribute name='mcs_name' />
                                        <attribute name='mcs_username' />
                                        <attribute name='mcs_state' />
                                        <filter type='and' >
                                            <condition attribute='statecode' operator='eq' value='0' />
                                        </filter>
                                    </entity>
                                </fetch>";
                var fetch = new FetchExpression(xml);
                var response = organizationProxy.RetrieveMultiple(fetch);
                if (response.Entities.Count > 0)
                {
                    result.data =  response.Entities.Select(x=>new OrderListDTD
                    {
                        mcs_name =x.GetAttributeValue<string>("mcs_name"),
                        mcs_state = x.GetAttributeValue<OptionSetValue>("mcs_state").Value.ToString(),
                        mcs_username =x.GetAttributeValue<string>("mcs_username")
                    });
                    result.code = 200;
                }

需要应用的js脚本文件，mcs_common.js

var CRM = window.CRM || {};
CRM.Common = CRM.Common || {};
(function () {
    this.createAsyn = function (entitySetName, entity) {
        /// <summary>异步创建实体记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entity" type="Object">要创建的记录对象，属性是要创建的记录的字段名称，属性值是字段的值</param>       
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.createAsyn entitySetName parameter must be a string.");
        }
        if (isNullOrUndefined(entity)) {
            throw new Error("CRM.Common.createAsyn entity parameter must not be null or undefined.");
        }

        return new Promise(function (resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("POST", encodeURI(getWebAPIPath() + entitySetName), true);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            req.onreadystatechange = function () {
                if (this.readyState == 4 /* complete */) {
                    req.onreadystatechange = null;
                    if (this.status == 204) {
                        var returnEntityID = req.getResponseHeader("OData-EntityId");
                        resolve(returnEntityID.substring(returnEntityID.indexOf("(") + 1, returnEntityID.indexOf(")")));
                    }
                    else {
                        reject(CRM.Common.errorHandler(JSON.parse(this.response).error.message));
                    }
                }
            };
            req.send(JSON.stringify(entity));
        });
    };

    this.createSync = function (entitySetName, entity, successCallback, errorCallback) {
        /// <summary>同步创建实体记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entity" type="Object">要创建的记录对象，属性是要创建的记录的字段名称，属性值是字段的值</param>       
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.createSync entitySetName parameter must be a string.");
        }
        if (isNullOrUndefined(entity)) {
            throw new Error("CRM.Common.createSync entity parameter must not be null or undefined.");
        }
        var req = new XMLHttpRequest();
        req.open("POST", encodeURI(getWebAPIPath() + entitySetName), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 204) {
                    var returnEntityID = req.getResponseHeader("OData-EntityId");
                    successCallback(returnEntityID.substring(returnEntityID.indexOf("(") + 1, returnEntityID.indexOf(")")));
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send(JSON.stringify(entity));
    }

    this.querySync = function (queryString, useFormattedValue, successCallback, errorCallback) {
        /// <summary>异步查询</summary>
        /// <param name="queryString" type="String">查询字符串，包括实体的逻辑名称(复数)</param>
        /// <param name="useFormattedValue" type="Boolean">返回的结果是否格式化</param>
        if (!isString(queryString)) {
            throw new Error("CRM.Common.querySync queryString parameter must be a string.");
        }
        if (!isBoolean(useFormattedValue)) {
            throw new Error("CRM.Common.querySync useFormattedValue parameter must be a boolean.");
        }
        var req = new XMLHttpRequest();
        req.open("GET", encodeURI(getWebAPIPath() + queryString), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        if (useFormattedValue) {
            req.setRequestHeader("Prefer", "odata.include-annotations=\"OData.Community.Display.V1.FormattedValue\"");
        }
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 200) {
                    successCallback(JSON.parse(req.responseText));
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send();
    };

    this.queryAsyn = function (queryString, useFormattedValue) {
        /// <summary>同步查询</summary>
        /// <param name="queryString" type="String">查询字符串，包括实体的逻辑名称(复数)</param>
        /// <param name="useFormattedValue" type="Boolean">返回的结果是否格式化</param>
        if (!isString(queryString)) {
            throw new Error("CRM.Common.queryAsyn queryString parameter must be a string.");
        }
        return new Promise(function (resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("GET", encodeURI(getWebAPIPath() + queryString), true);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            if (useFormattedValue) {
                req.setRequestHeader("Prefer", "odata.include-annotations=\"OData.Community.Display.V1.FormattedValue\"");
            }
            req.onreadystatechange = function () {
                if (this.readyState == 4 /* complete */) {
                    req.onreadystatechange = null;
                    if (this.status == 200) {
                        resolve(JSON.parse(this.responseText));
                    }
                    else {
                        reject(CRM.Common.errorHandler(JSON.parse(this.responseText).error.message));
                    }
                }
            };
            req.send();
        });
    };

    this.queryAsynAdmin = function (queryString, useFormattedValue) {
        /// <summary>代理管理员异步查询</summary>
        /// <param name="queryString" type="String">查询字符串，包括实体的逻辑名称(复数)</param>
        /// <param name="useFormattedValue" type="Boolean">返回的结果是否格式化</param>
        if (!isString(queryString)) {
            throw new Error("CRM.Common.queryAsyn queryString parameter must be a string.");
        }
        var id = this.getadminuserid();
        return new Promise(function (resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("GET", encodeURI(getWebAPIPath() + queryString), true);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            if (useFormattedValue) {
                req.setRequestHeader("Prefer", "odata.include-annotations=\"OData.Community.Display.V1.FormattedValue\"");
            }
            req.setRequestHeader("MSCRMCallerID", id);
            req.onreadystatechange = function () {
                if (this.readyState == 4 /* complete */) {
                    req.onreadystatechange = null;
                    if (this.status == 200) {
                        resolve(JSON.parse(this.responseText));
                    }
                    else {
                        reject(CRM.Common.errorHandler(JSON.parse(this.responseText).error.message));
                    }
                }
            };
            req.send();
        });
    };
    this.querySyncAdmin = function (queryString, useFormattedValue, successCallback, errorCallback) {
        /// <summary>代理管理员的身份同步查询</summary>
        /// <param name="queryString" type="String">查询字符串，包括实体的逻辑名称(复数)</param>
        /// <param name="useFormattedValue" type="Boolean">返回的结果是否格式化</param>
        if (!isString(queryString)) {
            throw new Error("CRM.Common.querySync queryString parameter must be a string.");
        }
        if (!isBoolean(useFormattedValue)) {
            throw new Error("CRM.Common.querySync useFormattedValue parameter must be a boolean.");
        }
        var id = this.getadminuserid();
        var req = new XMLHttpRequest();
        req.open("GET", encodeURI(getWebAPIPath() + queryString), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        if (useFormattedValue) {
            req.setRequestHeader("Prefer", "odata.include-annotations=\"OData.Community.Display.V1.FormattedValue\"");
        }
        req.setRequestHeader("MSCRMCallerID", id);
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 200) {
                    successCallback(JSON.parse(req.responseText));
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send();
    };
    this.updateAsyn = function (entitySetName, entityId, entity) {
        /// <summary>异步更新一条记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entityId" type="String">实体记录的主键，GUID</param>
        /// <param name="entity" type="Object">要更新的记录对象，属性是要更新的记录的字段名称，属性值是字段的值</param>
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.updateAsyn entitySetName parameter must be a string.");
        }
        if (!isString(entityId)) {
            throw new Error("CRM.Common.updateAsyn entityId parameter must be a string.");
        }
        if (isNullOrUndefined(entity)) {
            throw new Error("CRM.Common.updateAsyn entity parameter must not be null or undefined.");
        }
        return new Promise(function (resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("PATCH", encodeURI(getWebAPIPath() + entitySetName + "(" + entityId + ")"), true);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            req.onreadystatechange = function () {
                if (this.readyState == 4 /* complete */) {
                    req.onreadystatechange = null;
                    if (this.status == 204) {
                        resolve();
                    }
                    else {
                        reject(CRM.Common.errorHandler(JSON.parse(this.response).error.message));
                    }
                }
            };
            req.send(JSON.stringify(entity));
        });
    };

    this.updateSync = function (entitySetName, entityId, entity, successCallback, errorCallback) {
        /// <summary>同步更新一条记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entityId" type="String">实体记录的主键，GUID</param>
        /// <param name="entity" type="Object">要更新的记录对象，属性是要更新的记录的字段名称，属性值是字段的值</param>
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.updateAsyn entitySetName parameter must be a string.");
        }
        if (!isString(entityId)) {
            throw new Error("CRM.Common.updateAsyn entityId parameter must be a string.");
        }
        if (isNullOrUndefined(entity)) {
            throw new Error("CRM.Common.updateAsyn entity parameter must not be null or undefined.");
        }

        var req = new XMLHttpRequest();
        req.open("PATCH", encodeURI(getWebAPIPath() + entitySetName + "(" + entityId + ")"), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 204) {
                    successCallback();
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send(JSON.stringify(entity));
    };

    this.updateSyncAdmin = function (entitySetName, entityId, entity, successCallback, errorCallback) {
        /// <summary>代理管理员身份同步更新一条记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entityId" type="String">实体记录的主键，GUID</param>
        /// <param name="entity" type="Object">要更新的记录对象，属性是要更新的记录的字段名称，属性值是字段的值</param>
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.updateAsyn entitySetName parameter must be a string.");
        }
        if (!isString(entityId)) {
            throw new Error("CRM.Common.updateAsyn entityId parameter must be a string.");
        }
        if (isNullOrUndefined(entity)) {
            throw new Error("CRM.Common.updateAsyn entity parameter must not be null or undefined.");
        }
        var id = this.getadminuserid();
        var req = new XMLHttpRequest();
        req.open("PATCH", encodeURI(getWebAPIPath() + entitySetName + "(" + entityId + ")"), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        req.setRequestHeader("MSCRMCallerID", id);
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 204) {
                    successCallback();
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send(JSON.stringify(entity));
    };

    this.updateOneFieldSync = function (entitySetName, entityId, fieldName, fieldValue, successCallback, errorCallback) {
        /// <summary>同步更新实体一条记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entityId" type="String">实体记录的主键，GUID</param>
        /// <param name="fieldName" type="String">要更新的字段的逻辑名称</param>
        /// <param name="fieldValue" type="Object">要更新的字段的值</param>
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.updateOneFieldSync entitySetName parameter must be a string.");
        }
        if (!isString(entityId)) {
            throw new Error("CRM.Common.updateOneFieldSync entityId parameter must be a string.");
        }

        var req = new XMLHttpRequest();
        req.open("PUT", encodeURI(getWebAPIPath() + entitySetName + "(" + entityId + ")/" + fieldName), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 204) {
                    successCallback();
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send(JSON.stringify({ "value": fieldValue }));
    };

    this.updateOneFieldSyncAdmin = function (entitySetName, entityId, fieldName, fieldValue, successCallback, errorCallback) {
        /// <summary>代理管理员身份同步更新实体一条记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entityId" type="String">实体记录的主键，GUID</param>
        /// <param name="fieldName" type="String">要更新的字段的逻辑名称</param>
        /// <param name="fieldValue" type="Object">要更新的字段的值</param>
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.updateOneFieldSync entitySetName parameter must be a string.");
        }
        if (!isString(entityId)) {
            throw new Error("CRM.Common.updateOneFieldSync entityId parameter must be a string.");
        }
        var id = this.getadminuserid();
        var req = new XMLHttpRequest();
        req.open("PUT", encodeURI(getWebAPIPath() + entitySetName + "(" + entityId + ")/" + fieldName), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        req.setRequestHeader("MSCRMCallerID", id);
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 204) {
                    successCallback();
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send(JSON.stringify({ "value": fieldValue }));
    };

    this.updateOneFieldAsyn = function (entitySetName, entityId, fieldName, fieldValue) {
        /// <summary>异步更新实体一条记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entityId" type="String">实体记录的主键，GUID</param>
        /// <param name="fieldName" type="String">要更新的字段的逻辑名称</param>
        /// <param name="fieldValue" type="Object">要更新的字段的值</param>
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.updateOneFieldAsyn entitySetName parameter must be a string.");
        }
        if (!isString(entityId)) {
            throw new Error("CRM.Common.updateOneFieldAsyn entityId parameter must be a string.");
        }
        return new Promise(function (resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("PUT", encodeURI(getWebAPIPath() + entitySetName + "(" + entityId + ")/" + fieldName), true);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            req.onreadystatechange = function () {
                if (this.readyState == 4 /* complete */) {
                    req.onreadystatechange = null;
                    if (this.status == 204) {
                        resolve();
                    }
                    else {
                        reject(CRM.Common.errorHandler(JSON.parse(this.response).error.message));
                    }
                }
            };
            req.send(JSON.stringify({ "value": fieldValue }));
        });
    };

    this.deleteAsyn = function (entitySetName, entityId) {
        /// <summary>异步删除一条记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entityId" type="String">实体记录的主键，GUID</param>
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.deleteAsyn entitySetName parameter must be a string.");
        }
        if (!isString(entityId)) {
            throw new Error("CRM.Common.deleteAsyn entityId parameter must be a string.");
        }
        return new Promise(function (resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("DELETE", encodeURI(getWebAPIPath() + entitySetName + "(" + entityId + ")"), true);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            req.onreadystatechange = function () {
                if (this.readyState == 4 /* complete */) {
                    req.onreadystatechange = null;
                    if (this.status == 204) {
                        resolve();
                    }
                    else {
                        reject(CRM.Common.errorHandler(JSON.parse(this.response).error.message));
                    }
                }
            };
            req.send();
        });
    };

    this.deleteSync = function (entitySetName, entityId, successCallback, errorCallback) {
        /// <summary>同步删除一条记录</summary>
        /// <param name="entitySetName" type="String">实体的逻辑名称(复数)</param>
        /// <param name="entityId" type="String">实体记录的主键，GUID</param>
        if (!isString(entitySetName)) {
            throw new Error("CRM.Common.deleteSync entitySetName parameter must be a string.");
        }
        if (!isString(entityId)) {
            throw new Error("CRM.Common.deleteSync entityId parameter must be a string.");
        }

        var req = new XMLHttpRequest();
        req.open("DELETE", encodeURI(getWebAPIPath() + entitySetName + "(" + entityId + ")"), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 204) {
                    successCallback();
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send();
    };

    this.invokeFunctionAsyn = function (functionPara) {
        /// <summary>异步执行一个函数</summary>
        /// <param name="functionPara" type="String">函数的名称及参数</param>
        if (!isString(queryString)) {
            throw new Error("CRM.Common.invokeFunctionAsyn functionPara parameter must be a string.");
        }
        return new Promise(function (resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("GET", encodeURI(getWebAPIPath() + functionPara), true);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            req.onreadystatechange = function () {
                if (this.readyState == 4 /* complete */) {
                    req.onreadystatechange = null;
                    if (this.status == 200) {
                        resolve(JSON.parse(this.responseText));
                    }
                    else {
                        reject(CRM.Common.errorHandler(JSON.parse(this.response).error.message));
                    }
                }
            };
            req.send();
        });
    };

    this.invokeFunctionSync = function (functionPara) {
        /// <summary>异步执行一个函数</summary>
        /// <param name="functionPara" type="String">函数的名称及参数</param>
        if (!isString(queryString)) {
            throw new Error("CRM.Common.invokeFunctionSync functionPara parameter must be a string.");
        }

        var req = new XMLHttpRequest();
        req.open("GET", encodeURI(getWebAPIPath() + functionPara), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        req.send();
    }

    this.invokeActionAsyn = function (actionUrl, actionPara) {
        /// <summary>异步执行一个操作</summary>
        /// <param name="actionUrl" type="String">操作的URL</param>
        /// <param name="actionPara" type="Object">必须的操作参数</param>
        if (!isString(actionUrl)) {
            throw new Error("CRM.Common.invokeActionAsyn actionUrl parameter must be a string.");
        }
        if (isNullOrUndefined(actionPara)) {
            throw new Error("CRM.Common.invokeActionAsyn actionPara parameter must not be null or undefined.");
        }
        return new Promise(function (resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("POST", encodeURI(getWebAPIPath() + actionUrl), true);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            req.onreadystatechange = function () {
                if (this.readyState == 4 /* complete */) {
                    req.onreadystatechange = null;
                    if (this.status == 200 || this.status == 204) {
                        //successCallback(JSON.parse(this.response));
                        //resolve(JSON.parse(this.response));
                        //return JSON.parse(this.response);
                        resolve(JSON.parse(this.response));
                    }
                    else {
                        // return JSON.parse(this.response);
                        reject(JSON.parse(this.response));
                    }
                }
            };
            req.send(JSON.stringify(actionPara));
        });
    };

    this.invokeActionSync = function (actionUrl, actionPara, successCallback, errorCallback) {
        /// <summary>同步执行一个操作</summary>
        /// <param name="actionUrl" type="String">操作的URL</param>
        /// <param name="actionPara" type="Object">必须的操作参数</param>
        if (!isString(actionUrl)) {
            throw new Error("CRM.Common.invokeActionSync actionUrl parameter must be a string.");
        }
        if (isNullOrUndefined(actionPara)) {
            throw new Error("CRM.Common.invokeActionSync actionPara parameter must not be null or undefined.");
        }

        var req = new XMLHttpRequest();
        req.open("POST", encodeURI(getWebAPIPath() + actionUrl), false);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");
        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 200 || this.status == 204) {
                    successCallback();
                }
                else {
                    errorCallback(req);
                }
            }
        };
        req.send(JSON.stringify(actionPara));
    };

    this.getDataQueryStringValueByName = function (name) {
        /// <summary>获取Web资源中通过data参数传递过来的参数值</summary>
        /// <param name="name" type="String">data参数中参数的名称</param>
        if (!isString(name)) {
            throw new Error("CRM.Common.getDataQueryStringValueByName name parameter must be a string.");
        }
        var returnValue = "";
        if (location.search != "") {
            var vals = location.search.substr(1).split("&");
            for (var i in vals) {
                vals[i] = vals[i].replace(/\+/g, '').split('=');
            }
            for (var i in vals) {
                if (vals[i][0].toLowerCase() == "data") {
                    var match = RegExp('[?&]?' + name + '=([^&]*)').exec(decodeURIComponent(vals[i][1]));
                    if (match != null) {
                        returnValue = match[1].replace(/\+/g, '');
                    }
                }
            }
        }
        return returnValue;
    };

    this.getQueryStringValueByName = function (name) {
        /// <summary>获取Web资源中URL传递过来的参数值</summary>
        /// <param name="name" type="String">参数的名称</param>
        if (!isString(name)) {
            throw new Error("CRM.Common.getQueryStringValueByName name parameter must be a string.");
        }
        var returnValue = "";
        if (location.search != "") {
            var match = RegExp('[?&]?' + name + '=([^&]*)').exec(decodeURIComponent(location.search));
            returnValue = match && match[1].replace(/\+/g, '')
        }
        return returnValue;
    };

    this.convertUTCToLocalTime = function (UTCDate) {
        /// <summary>将UTC时间转换为本地时间</summary>
        /// <param name="UTCDate" type="Date">你要转换的UTC时间</param>
        var timeOffset = -((new Date()).getTimezoneOffset() / 60);
        UTCDate.setHours(UTCDate.getHours() + timeOffset);
        return UTCDate;
    };

    this.convertStringToDatetime = function (dateString) {
        /// <summary>将2016-02-16T01:01:01Z 格式的字符串转换为日期类型</summary>
        /// <param name="dateString" type="String">要转换的字符串</param>
        if (!isString(dateString)) {
            throw new Error("CRM.Common.convertStringToDatetime dateString parameter must be a string.");
        }
        var reggie = /(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z/;
        var dateArray = reggie.exec(dateString);
        var dateObject = new Date(
            (+dateArray[1]),
            (+dateArray[2]) - 1,
            (+dateArray[3]),
            (+dateArray[4]),
            (+dateArray[5]),
            (+dateArray[6])
        );
        return dateObject;
    };

    //增加获取URL的方法 20180403
    this.getWebAPIPathFun = function () {
        return getClientUrl() + "/api/data/v8.2/";
    };

    //Internal supporting functions
    function getClientUrl() {
        //Get the organization URL
        var tXrm;
        if (typeof GetGlobalContext == "function" &&
            typeof GetGlobalContext().getClientUrl == "function") {
            return GetGlobalContext().getClientUrl();
        }
        else {
            //If GetGlobalContext is not defined check for Xrm.Page.context;
            if (typeof Xrm != "undefined" &&
                typeof Xrm.Page != "undefined" &&
                typeof Xrm.Page.context != "undefined" &&
                typeof Xrm.Page.context.getClientUrl == "function") {
                try {

                    return Xrm.Page.context.getClientUrl();
                } catch (e) {
                    throw new Error("Xrm.Page.context.getClientUrl is not available.");
                }
            }
            else if (parent.Xrm != undefined && parent.Xrm.Page != undefined && parent.Xrm.Page.context != undefined) {
                return parent.Xrm.Page.context.getClientUrl();
            }
            else {
                try {
                    tXrm = window.opener.Xrm;
                    if (tXrm == null || tXrm == undefined) tXrm = window.opener.window.parent.Xrm;
                    return tXrm.Page.context.getClientUrl();
                } catch (e) { }
                throw new Error("Context is not available.");
            }
        }
    }
    function getWebAPIPath() {
        return getClientUrl() + "/api/data/v8.2/";
    }

    //Internal validation functions
    function isString(obj) {
        if (typeof obj === "string") { return true; }
        return false;

    }
    function isBoolean(obj) {
        if (typeof obj === "boolean") { return true; }
        return false;
    }
    function isNull(obj) {
        if (obj === null) { return true; }
        return false;
    }
    function isUndefined(obj) {
        if (typeof obj === "undefined") { return true; }
        return false;
    }
    function isFunction(obj) {
        if (typeof obj === "function") { return true; }
        return false;
    }
    function isNullOrUndefined(obj) {
        if (isNull(obj) || isUndefined(obj)) { return true; }
        return false;
    }
    function isFunctionOrNull(obj) {
        if (isNull(obj)) { return true; }
        if (isFunction(obj)) { return true; }
        return false;
    }

    this.errorHandler = function (resp) {
        return new Error(resp);
    };

    this.getLocalizedResourcesByClassName = function (className, lcid) {
        if (lcid == null || lcid == undefined) lcid = this.getContext().getUserLcid();

        //Begin 拼接查询语句
        var requrl = new Array();
        requrl.push('hw_languages?$select=hw_langkey,hw_name,hw_lc&$filter=hw_lc eq ' + lcid);
        var classNameNotEmpty = (typeof className != 'undefined' && className != '');
        if (!classNameNotEmpty) {
            console.log('className cannot be empty!');
            return null;
        }
        if (className) requrl.push(" and hw_entityname eq '" + className + "'");
        //End 拼接查询语句

        var returnObject;
        this.querySync(requrl.join(''), false, function (ret) {
            var tmpObj = {};
            if (typeof ret == 'object' && ret != null && ret.value != null) {

                //Begin 如果获取不到对应的语言，默认获取英文
                if (ret.value.length > 0) {
                    //将数组转换为对象
                    for (var i = 0; i < ret.value.length; i++) {
                        tmpObj[ret.value[i]["hw_langkey"]] = ret.value[i]["hw_name"];
                    }
                }
                else if (ret.value.length == 0 && lcid != 1033) //第一次查不到则查英文
                {
                    ret = CRM.Common.getLocalizedResourcesByClassName(className, 1033);
                }
                else //英文也查不到时
                {
                    errorCallback('no language resources for ' + className);
                }
                //End 如果获取不到对应的语言，默认获取英文 
            } else {
                console.log("Get Language Resource but nothing returned!");
            }
            returnObject = tmpObj;
        }, function (err) {
            console.log(err);
        });
        return returnObject;
    };

    this.getLocalizedResourcesByClassNameAsync = function (className, lcid, successCallback, errorCallback) {
        if (lcid == null || lcid == undefined) lcid = this.getContext().getUserLcid();

        //Begin 拼接查询语句
        var requrl = new Array();
        requrl.push('hw_languages?$select=hw_langkey,hw_name,hw_lc&$filter=hw_lc eq ' + lcid);
        var classNameNotEmpty = (typeof className != 'undefined' && className != '');
        if (!classNameNotEmpty) {
            console.log('className cannot be empty!');
            return null;
        }
        if (className) requrl.push(" and hw_entityname eq '" + className + "'");
        //End 拼接查询语句

        var req = new XMLHttpRequest();
        req.open("GET", encodeURI(getWebAPIPath() + requrl.join('')), true);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");

        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 200) {
                    var responseObj = JSON.parse(this.responseText);
                    var tmpObj = {};
                    if (typeof responseObj == 'object' && responseObj != null && responseObj.value != null) {

                        //Begin 如果获取不到对应的语言，默认获取英文
                        if (responseObj.value.length > 0) {
                            //将数组转换为对象 
                            for (var i = 0; i < responseObj.value.length; i++) {
                                tmpObj[responseObj.value[i]["hw_langkey"]] = responseObj.value[i]["hw_name"];
                            }
                        }
                        else if (responseObj.value.length == 0 && lcid != 1033) //第一次查不到则查英文
                        {
                            responseObj = CRM.Common.getLocalizedResourcesByClassName(className, 1033);
                        }
                        else //英文也查不到时
                        {
                            errorCallback('no language resources for ' + className);
                        }
                        //End 如果获取不到对应的语言，默认获取英文 
                        successCallback(tmpObj);
                    } else {
                        successCallback({});
                        console.log("Get Language Resource but nothing returned!");
                    }
                }
                else {
                    var err = JSON.parse(this.responseText).error.message;
                    if (typeof errorCallback == 'function') errorCallback(err);
                }
            }
        };
        req.send();
    };

    this.getLocalizedStringByKey = function (langKey, lcid) {
        if (lcid == null || lcid == undefined) lcid = this.getContext().getUserLcid();

        //Begin 拼接查询语句
        var requrl = new Array();
        requrl.push('hw_languages?$select=hw_langkey,hw_name,hw_lc&$filter=hw_lc eq ' + lcid);
        var langkeyNotEmpty = (typeof langKey != 'undefined' && langKey != '');
        if (!langkeyNotEmpty) {
            console.log('langKey cannot be empty!');
            return null;
        }
        if (langkeyNotEmpty) requrl.push(" and hw_langkey eq '" + langKey + "'");
        //End 拼接查询语句

        var returnObject = "";
        this.querySync(requrl.join(''), false, function (ret) {
            if (typeof ret == 'object') {

                //Begin 如果获取不到对应的语言，默认获取英文
                if (ret != null && ret.value != null && ret.value.length > 0) {
                    returnObject = ret.value[0]["hw_name"];
                }
                else if (ret.value.length == 0 && lcid != 1033) //第一次查不到则查英文
                {
                    returnObject = CRM.Common.getLocalizedStringByKey(langKey, 1033);
                }
                if (ret.value.length == 0) returnObject = langKey; //英文也查不到时
                //End 如果获取不到对应的语言，默认获取英文

            } else {
                console.log("Get Language Resource but nothing returned!");
            }
        }, function (err) {
            console.log(err);
        });
        if (returnObject == "") returnObject = langKey;
        return returnObject;
    };

    this.getLocalizedStringByKeyAsync = function (langKey, lcid, successCallback, errorCallback) {
        if (lcid == null || lcid == undefined) lcid = this.getContext().getUserLcid();

        //Begin 拼接查询语句
        var requrl = new Array();
        requrl.push('hw_languages?$select=hw_langkey,hw_name,hw_lc&$filter=hw_lc eq ' + lcid);
        var langkeyNotEmpty = (typeof langKey != 'undefined' && langKey != '');
        if (!langkeyNotEmpty) {
            console.log('langKey cannot be empty!');
            return null;
        }
        if (langkeyNotEmpty) requrl.push(" and hw_langkey eq '" + langKey + "'");
        //End 拼接查询语句

        var req = new XMLHttpRequest();
        req.open("GET", encodeURI(getWebAPIPath() + requrl.join('')), true);
        req.setRequestHeader("Accept", "application/json");
        req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        req.setRequestHeader("OData-MaxVersion", "4.0");
        req.setRequestHeader("OData-Version", "4.0");

        req.onreadystatechange = function () {
            if (this.readyState == 4 /* complete */) {
                req.onreadystatechange = null;
                if (this.status == 200) {
                    var responseObj = JSON.parse(this.responseText);

                    if (typeof responseObj == 'object' && responseObj != null && responseObj.value != null) {

                        //Begin 如果获取不到对应的语言，默认获取英文
                        if (responseObj.value.length > 0) successCallback(responseObj.value[0]["hw_name"]);//查询到结果
                        else if (responseObj.value.length == 0 && lcid != 1033) {
                            successCallback(CRM.Common.getLocalizedStringByKey(langKey, 1033));
                        }
                        else if (responseObj.value.length == 0) successCallback(langKey); //英文也查不到时，直接返回langKey 
                        //End 如果获取不到对应的语言，默认获取英文 
                    } else {
                        successCallback(langKey);
                        console.log("Get Language Resource but nothing returned!");
                    }
                }
                else {
                    var err = JSON.parse(this.responseText).error.message;
                    if (typeof errorCallback == 'function') errorCallback(err);
                }
            }
        };
        req.send();
    };

    //创建人：易亮  创建时间：2016/6/16
    this.IsUserHasRoleSync = function (rolename, userid, successcallback, errorcallback) {
        /// <summary>判断给定的用户是否包含指定角色</summary>
        /// <param name="rolename" type="String">角色名称 </param>
        /// <param name="userid" type="String">用户guid</param>
        /// <param name="successcallback" type="function">成功回调函数</param>
        /// <param name="successcallback" type="function">失败回调函数</param>
        //参数示例： "受理员","{8775BCC2-1731-E611-80CD-BE2A9A382EA5}",function(){}, ,
        var fetchxml = "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true' no-lock='true'>\
                            <entity name='role'>\
                            <attribute name='name' />\
                            <attribute name='businessunitid' />\
                            <attribute name='roleid' />\
                            <filter type='and'>\
                                <condition attribute='name' operator='eq' value='"+ rolename + "' />\
                            </filter>\
                            <link-entity name='systemuserroles' from='roleid' to='roleid' visible='false' intersect='true'>\
                                <link-entity name='systemuser' from='systemuserid' to='systemuserid' alias='ad'>\
                                <filter type='and'>\
                                    <condition attribute='systemuserid' operator='eq'  value='"+ userid + "' />\
                                </filter>\
                                </link-entity>\
                            </link-entity>\
                            </entity>\
                        </fetch>";
        var url = encodeURI(getClientUrl() + "/api/data/v8.2/roles?fetchXml=" + fetchxml);
        var request = new XMLHttpRequest();
        request.open("GET", url, false);
        request.setRequestHeader("Accept", "application/json");
        request.setRequestHeader("OData-MaxVersion", "4.0");
        request.setRequestHeader("OData-Version", "4.0");
        request.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        request.onreadystatechange = function () {
            if (this.readyState == 4) {
                this.onreadystatechange = null;
                if (this.status == 200) {
                    var backjson = window.JSON.parse(this.responseText);
                    if (backjson.value.length > 0) {
                        successcallback();
                    }
                } else {
                    errorcallback(window.JSON.parse(this.response).error.message);
                }
            }
        };
        request.send();
    };
    //创建人：易亮  创建时间：2016/6/16
    this.IsCurrentUserHasRoleSync = function (rolename, successcallback, errorcallback) {
        /// <summary>判断当期用户是否包含指定角色</summary>
        /// <param name="rolename" type="String">角色名称 </param>
        /// <param name="successcallback" type="function">成功回调函数</param>
        /// <param name="successcallback" type="function">失败回调函数</param>
        //参数示例： "受理员",function(){},function(message){} ,
        var fetchxml = "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true' no-lock='true'>\
                            <entity name='role'>\
                            <attribute name='name' />\
                            <attribute name='businessunitid' />\
                            <attribute name='roleid' />\
                            <filter type='and'>\
                                <condition attribute='name' operator='eq' value='"+ rolename + "' />\
                            </filter>\
                            <link-entity name='systemuserroles' from='roleid' to='roleid' visible='false' intersect='true'>\
                                <link-entity name='systemuser' from='systemuserid' to='systemuserid' alias='ad'>\
                                <filter type='and'>\
                                    <condition attribute='systemuserid' operator='eq-userid' />\
                                </filter>\
                                </link-entity>\
                            </link-entity>\
                            </entity>\
                        </fetch>";
        var url = encodeURI(getClientUrl() + "/api/data/v8.2/roles?fetchXml=" + fetchxml);
        var request = new XMLHttpRequest();
        request.open("GET", url, false);
        request.setRequestHeader("Accept", "application/json");
        request.setRequestHeader("OData-MaxVersion", "4.0");
        request.setRequestHeader("OData-Version", "4.0");
        request.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        request.onreadystatechange = function () {
            if (this.readyState == 4) {
                this.onreadystatechange = null;
                if (this.status == 200) {
                    var backjson = window.JSON.parse(this.responseText);
                    if (backjson.value.length > 0) {
                        successcallback();
                    }
                    else {
                        errorcallback();
                    }
                } else {
                    errorcallback(window.JSON.parse(this.response).error.message);
                }

            }
        };
        request.send();
    };

    //创建人：余泽龙  创建时间：2016/9/13
    this.IsCurrentUserHasRolesSync = function (rolename, successcallback, errorcallback) {
        /// <summary>传入多个角色名，判断当期用户是否包含指定角色</summary>
        /// <param name="rolename" type="String">多个角色名称 </param>
        /// <param name="successcallback" type="function">成功回调函数</param>
        /// <param name="errorcallback" type="function">失败回调函数</param>
        //参数示例： "受理员",function(){},function(message){} ,

        var role = rolename.split(',');
        var fileter = "";
        for (var i = 0; i < role.length; i++) {
            fileter += "<condition attribute='name' operator='eq' value='" + role[i] + "' />";
        }
        var fetchxml = "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true' no-lock='true'>\
                            <entity name='role'>\
                            <attribute name='name' />\
                            <attribute name='businessunitid' />\
                            <attribute name='roleid' />\
                            <filter type='or'>"+
            fileter
            + "</filter>\
                            <link-entity name='systemuserroles' from='roleid' to='roleid' visible='false' intersect='true'>\
                                <link-entity name='systemuser' from='systemuserid' to='systemuserid' alias='ad'>\
                                <filter type='and'>\
                                    <condition attribute='systemuserid' operator='eq-userid' />\
                                </filter>\
                                </link-entity>\
                            </link-entity>\
                            </entity>\
                        </fetch>";
        var url = encodeURI(getClientUrl() + "/api/data/v8.2/roles?fetchXml=" + fetchxml);
        var request = new XMLHttpRequest();
        request.open("GET", url, false);
        request.setRequestHeader("Accept", "application/json");
        request.setRequestHeader("OData-MaxVersion", "4.0");
        request.setRequestHeader("OData-Version", "4.0");
        request.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        request.onreadystatechange = function () {
            if (this.readyState == 4) {
                this.onreadystatechange = null;
                if (this.status == 200) {
                    var backjson = window.JSON.parse(this.responseText);
                    if (backjson.value.length > 0) {
                        successcallback();
                    }
                    else {
                        errorcallback();
                    }
                } else {
                    errorcallback(window.JSON.parse(this.response).error.message);
                }

            }
        };
        request.send();
    };
    this.IsCurrentUserHasRolesAsync = function (rolename, successcallback, errorcallback) {
        /// <summary>传入多个角色名，判断当期用户是否包含指定角色</summary>
        /// <param name="rolename" type="String">多个角色名称 </param>
        /// <param name="successcallback" type="function">成功回调函数</param>
        /// <param name="errorcallback" type="function">失败回调函数</param>
        //参数示例： "受理员",function(){},function(message){} ,

        var role = rolename.split(',');
        var fileter = "";
        for (var i = 0; i < role.length; i++) {
            fileter += "<condition attribute='name' operator='eq' value='" + role[i] + "' />";
        }
        var fetchxml = "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true' no-lock='true'>\
            <entity name='role'>\
            <attribute name='name' />\
            <attribute name='businessunitid' />\
            <attribute name='roleid' />\
            <filter type='or'>"+ fileter + "</filter>\
            <link-entity name='systemuserroles' from='roleid' to='roleid' visible='false' intersect='true'>\
                <link-entity name='systemuser' from='systemuserid' to='systemuserid' alias='ad'>\
                <filter type='and'>\
                    <condition attribute='systemuserid' operator='eq-userid' />\
                </filter>\
                </link-entity>\
            </link-entity>\
            </entity>\
        </fetch>";
        this.queryAsyn('roles?fetchXml=' + fetchxml, false).then(function (ret) {
            if (ret.value.length > 0) successcallback();
            else errorcallback();
        }).catch(function () {
            errorcallback();
        });

    };

    //创建人：余泽龙  创建时间：2016/6/21
    this.callAPISync = function (url, successCallback, errorCallback) {
        /// <summary>同步调用中间层</summary>
        /// <param name="url" type="String"></param>
        //修改人tencent 2016/11/02 改成统一调用，整理代码时避免漏改
        this.getMiddleWareDatas(url, false, successCallback, errorCallback);
    };

    //创建人：余泽龙  创建时间：2016/6/29
    this.callAPIPostSync = function (url, object, successCallback, errorCallback) {
        /// <summary>同步调用中间层接口POST方式</summary>
        /// <param name="url" type="String"></param>
        /// <param name="object" type="Object"></param>   
        //修改人tencent 2016/11/02 改成统一调用，整理代码时避免漏改
        this.postMiddleWareDatas(url, object, false, successCallback, errorCallback);
    }
    //创建人：余泽龙  创建时间：2016/7/8
    this.callAPIPostAsyn = function (url, object, successCallback, errorCallback) {
        /// <summary>异步调用中间层接口POST方式</summary>
        /// <param name="url" type="String"></param>
        /// <param name="object" type="Object"></param>       
        //修改人tencent 2016/11/02 改成统一调用，整理代码时避免漏改
        this.postMiddleWareDatas(url, object, true, successCallback, errorCallback);
    }
    //创建人:徐志强，罗勇20160911修改，使用刘荣提供的正则表达式
    this.PhoneCheck = function (ExecutionContextObj) {
        var fetchxml = "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true' no-lock='true'>\
                          <entity name='hw_sc'>\
<attribute name='hw_name' />\
                            <link-entity name='businessunit' from='hw_sc' to='hw_scid' alias='ai'>\
                              <link-entity name='systemuser' from='businessunitid' to='businessunitid' alias='aj'>\
                                <filter type='and'>\
                                  <condition attribute='systemuserid' operator='eq-userid' />\
                                </filter>\
                              </link-entity>\
                            </link-entity>\
                            <link-entity name='hw_country' from='hw_countryid' to='hw_country' visible='false' link-type='outer' alias='country'>\
                              <attribute name='hw_telre' alias='country_telre'/>\
                            </link-entity>\
                          </entity>\
                        </fetch>";
        var query = "hw_scs?fetchXml=" + fetchxml;
        CRM.Common.querySync(query, true, function (responseJSON) {
            if (responseJSON.value.length > 0) {
                var phone1 = responseJSON.value[0].country_telre;
                //var phone1 = /(^([0](\d{2,3}-))?\d{7,8})$|((\+86)|(86))?(147|(1[3|5|7|8|])[0-9]\d{8}$)/;
                var phone = new RegExp(phone1);
                var attribute = ExecutionContextObj.getEventSource().getName();
                var imeiorsn = Xrm.Page.getAttribute(attribute).getValue();
                if (imeiorsn != null && imeiorsn != '' && !phone.test(imeiorsn.trim())) {
                    var errMsg = CRM.Common.getLocalizedStringByKey('common_checkphoneformat');
                    Xrm.Page.getControl(attribute).setNotification(errMsg, "98EE9784-BADE-470A-8B67-CCC05A013AB1");
                    return;
                }
                else {
                    Xrm.Page.getControl(attribute).clearNotification("98EE9784-BADE-470A-8B67-CCC05A013AB1");
                }
            }
        }, function () { });

    }

    //创建人:李文涛  2017/9/18
    this.NewPhoneCheck = function (ExecutionContextObj) {
        var fetchxml = "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true' no-lock='true'>\
                          <entity name='hw_sc'>\
<attribute name='hw_name' />\
                            <link-entity name='businessunit' from='hw_sc' to='hw_scid' alias='ai'>\
                              <link-entity name='systemuser' from='businessunitid' to='businessunitid' alias='aj'>\
                                <filter type='and'>\
                                  <condition attribute='systemuserid' operator='eq-userid' />\
                                </filter>\
                              </link-entity>\
                            </link-entity>\
                            <link-entity name='hw_country' from='hw_countryid' to='hw_country' visible='false' link-type='outer' alias='country'>\
                              <attribute name='hw_telre' alias='country_telre'/>\
                            </link-entity>\
                          </entity>\
                        </fetch>";
        var query = "hw_scs?fetchXml=" + fetchxml;
        CRM.Common.querySync(query, true, function (responseJSON) {
            if (responseJSON.value.length > 0) {
                var phone1 = responseJSON.value[0].country_telre;
                //var phone1 = /(^([0](\d{2,3}-))?\d{7,8})$|((\+86)|(86))?(147|(1[3|5|7|8|])[0-9]\d{8}$)/;
                var phone = new RegExp(phone1);
                var attribute = ExecutionContextObj.getEventSource().getName();
                var imeiorsn = Xrm.Page.getAttribute(attribute).getValue();
                if (imeiorsn != null && imeiorsn != '' && !phone.test(imeiorsn.trim())) {
                    var errMsg = CRM.Common.getLocalizedStringByKey('common_checkphoneformat');
                    Xrm.Page.getControl(attribute).setNotification(errMsg, "98EE9784-BADE-470A-8B67-CCC05A013AB1");
                    HW.incidentFunctions.showOrHideWebRes("WebResource_queryphonemakeuseofnumber", false);
                    return;
                }
                else {
                    Xrm.Page.getControl(attribute).clearNotification("98EE9784-BADE-470A-8B67-CCC05A013AB1");
                    HW.incidentFunctions.showOrHideWebRes("WebResource_queryphonemakeuseofnumber", true);
                }
            }
        }, function () { });

    }

    //lookup赋值 徐志强
    this.setlookupvalue = function (LookUpControlId, Type, Name, Id) {
        //Id 规范必须包括花括号及大写 commented by Tencent Lee 2017/8/12
        if (Xrm.Page.getAttribute(LookUpControlId) == null) return;
        if (Id.indexOf('{') < 0) Id = '{' + Id + '}';
        Id = Id.toUpperCase();
        var lookupReference = [];
        lookupReference[0] = {};
        lookupReference[0].id = Id;
        lookupReference[0].entityType = Type;
        lookupReference[0].name = Name;
        Xrm.Page.getAttribute(LookUpControlId).setValue(lookupReference);
    };
    //imei sn 格式检测
    this.ImeiorSNcheck = function (ExecutionContextObj) {
        var check = /^[a-zA-Z0-9]{8,30}$/;
        var attribute = ExecutionContextObj.getEventSource().getName();
        var imeiorsn = Xrm.Page.getAttribute(attribute).getValue();
        if (imeiorsn != null && imeiorsn != '' && !check.test(imeiorsn.trim())) {
            var errMsg = this.getLocalizedStringByKey('common_checkimei');
            Xrm.Page.ui.setFormNotification(errMsg, "ERROR", "98EE9784-BADE-470A-8B67-CCC05A013ABA");
            Xrm.Page.getAttribute(attribute).setValue("");
            return;
        }
        else {
            Xrm.Page.getControl(attribute).clearNotification("98EE9784-BADE-470A-8B67-CCC05A013AB1");
            Xrm.Page.ui.clearFormNotification("98EE9784-BADE-470A-8B67-CCC05A013ABA");
        }
    }

    this.getContext = function () {
        //获取当前上下文 tencent 2016/11/02
        var context = null;
        var tXrm = typeof Xrm == 'undefined' ? parent.Xrm : Xrm;
        try {
            if (tXrm == null || tXrm == undefined) tXrm = window.opener.Xrm;
            if (tXrm == null || tXrm == undefined) tXrm = window.opener.window.parent.Xrm;
        } catch (e) { }
        if (typeof tXrm.Page != 'undefined') {
            if (typeof tXrm.Page.context != 'undefined') {
                context = tXrm.Page.context;
            }
        }
        if (context == null) {
            console.log('context is null');
        };
        return context;
    }

    // zhanghuang add 20161116
    this.getAuthorizationStr = function () {
        return this.getTokenStr();
    };

    this.getTokenStr = function (context) {
        var retString = '';
        var requestMain = "<s:Envelope xmlns:s='http://schemas.xmlsoap.org/soap/envelope/'>";
        requestMain += "<s:Body>";
        requestMain += "<Execute xmlns='http://schemas.microsoft.com/xrm/2011/Contracts/Services' xmlns:i='http://www.w3.org/2001/XMLSchema-instance'>";
        requestMain += "<request xmlns:a='http://schemas.microsoft.com/xrm/2011/Contracts'>";
        requestMain += "<a:Parameters xmlns:b='http://schemas.datacontract.org/2004/07/System.Collections.Generic' />";
        requestMain += "<a:RequestId i:nil='true' />";
        requestMain += "<a:RequestName>hw_crmRequestToken</a:RequestName>";
        requestMain += "</request>";
        requestMain += "</Execute>";
        requestMain += "</s:Body>";
        requestMain += "</s:Envelope>";
        var req = new XMLHttpRequest();
        req.open("POST", getClientUrl() + "/XRMServices/2011/Organization.svc/web", false);
        req.setRequestHeader("Accept", "application/xml, text/xml, */*");
        req.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
        req.setRequestHeader("SOAPAction", "http://schemas.microsoft.com/xrm/2011/Contracts/Services/IOrganizationService/Execute");
        req.onreadystatechange = function () {
            if (this.readyState == 4) {
                req.onreadystatechange = null;
                if (this.status == 200) {
                    var responseStr = this.responseText;
                    var searchedstr = responseStr.match(/XMLSchema"\>.+\<\/b:value\>/gm)
                    if (searchedstr != null) {
                        retString = searchedstr[0].substring(11, searchedstr[0].length - 10);
                    }
                } else {
                    console.log('err' + this.responseText);
                    throw new Error('Error when get token.' + this.responseText);
                }
            }
        };
        req.send(requestMain);
        return retString;
    };

    this.getMiddleWareDatas = function (reqURL, isAsync, successCallback, errorCallback) {
        //调用中间层GET方法 tencentlee 2016/10/28
        try {
            var req = new XMLHttpRequest();
            var reqUrl = this.getAPIUrl() + reqURL;
            req.open("GET", reqUrl, isAsync);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader('Authorization', 'Basic ' + this.getAuthorizationStr());
            req.onreadystatechange = function () {
                if (this.readyState == 4) {
                    if (this.status == 200) {
                        req.onreadystatechange = null;
                        if (this.responseText != "") {
                            var ret = JSON.parse(this.responseText);
                            if (typeof successCallback == 'function') {
                                successCallback(ret);
                            }
                        } else {
                            if (typeof errorCallback == 'function') errorCallback(this.status);
                        }
                    } else {
                        if (this.responseText != null) errorCallback(this.responseText);
                        else errorCallback(this);
                    }
                };
            }

            req.send();
        } catch (e) {
            console.log(e);
            if (e.name != undefined && e.name == "NetworkError") {
                console.log('网络错误，请稍后重试或联系管理员!');
            }
            errorCallback(e);
        };
    };
    this.postMiddleWareDatas = function (reqURL, postDatas, isAsync, successCallback, errorCallback) {
        //调用中间层GET方法 tencentlee 2016/10/28
        //postDatas:请求内容Object对象
        //isAsync：同步还是异步，true为异步,false为同步
        //successCallback：成功时的回调函数
        //errorCallback：失败时的回调函数
        try {
            var req = new XMLHttpRequest();
            var reqUrl = this.getAPIUrl() + reqURL;
            req.open('POST', reqUrl, isAsync);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader('Authorization', 'Basic ' + this.getAuthorizationStr());

            req.onreadystatechange = function () {
                if (this.readyState == 4) {
                    if (this.status == 200) {
                        req.onreadystatechange = null;
                        if (this.responseText != "") {
                            var ret = JSON.parse(this.responseText);
                            if (typeof successCallback == 'function') {
                                successCallback(ret);
                            }
                        } else {
                            if (typeof errorCallback == 'function') errorCallback(this.status);
                        }
                    } else {
                        if (this.responseText != null) errorCallback(this.responseText);
                        else errorCallback(this);
                    }
                };
            };

            req.send(JSON.stringify(postDatas));
        } catch (e) {
            console.log(e);
            if (e.name != undefined && e.name == "NetworkError") {
                //todo:show network error to user?
                console.log('网络错误，请稍后重试或联系管理员!');
            }
            errorCallback(e);
        };
    };
    this.APIUrl = '';
    this.getAPIUrl = function () {
        //获取中间层地址 tencent 
        if (CRM.Common.APIUrl != '') return CRM.Common.APIUrl;
        else {
            this.querySync("hw_configs?$top=1&$select=hw_value&$filter=hw_name eq 'apiurl'", false, function (ret) {
                if (ret.value != null && ret.value.length > 0) {
                    CRM.Common.APIUrl = ret.value[0].hw_value;
                }
            }, function (err) {
                console.log('getAPIUrl error:' + err);
            }, false);
        }
        return CRM.Common.APIUrl;
    }

    this.htmlEncode = function (str) {
        if (str) {
            return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\'/g, "&#39;").replace(/\"/g, "&quot;");
        }
        else {
            return "";
        }
    };
    this.isRowVersionMatch = function () {
        //判断数据版本是否一致
        var isRowVersionMatch = false;
        var entId = Xrm.Page.data.entity.getId();
        var entSetName = Xrm.Page.data.entity.getEntitySetName();
        this.querySync(entSetName + '(' + entId.replace('{', '').replace('}', '') + ')?$select=versionnumber', false, function (ret) {
            if (Xrm.Page.data.entity.getRowVersion() == ret.versionnumber)
                isRowVersionMatch = true;
        }, function (err) {
            Xrm.Utility.alertDialog('system error ,please contact system administrator!');
            console.log('query rowversion failed!');
            return false;
        });
        return isRowVersionMatch;
    };

    this.getAttr = function (attrId) {
        return Xrm.Page.getAttribute(attrId);
    };
    this.getCtrl = function (ctrlId) {
        return Xrm.Page.getControl(ctrlId);
    };
    this.getAttrValue = function (attrId) {
        var attr = this.getAttr(attrId); if (attr) {
            if (typeof attr.getValue() == 'string') {
                return attr.getValue().trim();
            }
            return attr.getValue();
        } else return null;
    };
    this.setAttrValue = function (attrId, val) {
        var attr = this.getAttr(attrId); if (attr) attr.setValue(val);
    };
    this.setCtrlVisible = function (ctrlId, flag) {
        var ctrl = this.getCtrl(ctrlId); if (ctrl) ctrl.setVisible(flag);
    };
    this.setCtrlDisabled = function (ctrlId, flag) {
        var ctrl = this.getCtrl(ctrlId); if (ctrl) ctrl.setDisabled(flag);
    };
    this.treplace = function (str) {
        if (typeof str == 'string') return str.replace('{', '').replace('}', '');
        return str;
    };
    this.setLookUpField = function (LookupId, Id, Name, Type) {
        var lookupReference = [];
        if (Id.indexOf('{') < 0) Id = '{' + Id + '}';
        Id = Id.toUpperCase();
        lookupReference[0] = {};
        lookupReference[0].id = Id;
        lookupReference[0].entityType = Type;
        lookupReference[0].name = Name;
        this.getAttr(LookupId).setValue(lookupReference);
    };
    // 获取CRMuserid
    // 获取CRMuserid
    this.getadminuserid = function () {
        var adminid = "";
        var fetchxml = "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>\
                            <entity name= 'mcs_cepconfig' >\
                                <attribute name='mcs_cepconfigid' />\
                                <attribute name='mcs_name' />\
                                <attribute name='createdon' />\
                                <attribute name='mcs_val' />\
                                <order attribute='mcs_name' descending='false' />\
                                <filter type='and'>\
                                    <condition attribute='mcs_name' operator='eq' value='CEP_Key_SystemUserId' />\
                                </filter>\
                            </entity >\
                        </fetch >";
        this.querySync("mcs_cepconfigs?fetchXml=" + fetchxml, false, function (data) {
            if (data.value.length > 0) {
                adminid = data.value[0].mcs_val;
            } else {
                adminid = null;
            }
        }, function (req) {
            adminid = null;
        });
        return adminid;
    };
    this.GetCurrentUserRoleNames = function (context) {
        //查询用户是否具有某种角色，多个角色用逗号分隔，传入多个角色时，具有其中一个角色则返回true WrittenBy:Tencent Lee
        //因ribbon调用三次的BUG,在ribbon.js里面调用一次缓存起来，下次无需再执行WebAPI查询

        var userRoles = []; //当前用户的所有角色ID    
        userRoles = context == null ? Xrm.Page.context.getUserRoles() : context.getUserRoles() || [];
        if (userRoles.length == 0) return false;
        var queryStrArr = [];
        queryStrArr.push('roles?$select=name&$filter=(');
        //拼接角色ID查询语句
        for (var i = 0; i < userRoles.length; i++) {
            queryStrArr.push('roleid eq ' + userRoles[i]);
            if (i != userRoles.length - 1) queryStrArr.push(' or ');
        }
        queryStrArr.push(')');
        var retArray = [];
        CRM.Common.querySync(queryStrArr.join(''), false, function (ret) {
            if (ret.value.length > 0) {
                for (var i in ret.value) {
                    retArray.push(ret.value[i]['name']);
                }
            }
        }, function (err) {
            console.log(err);
        });
        return retArray;
    };
    this.IsUserHasRolesInCached = function (roleNamesString, cachedRoleNameArray) {
        //获取用户是否有缓存的角色名称 TencentLee 2017/6/7
        var roleNameArr = [];//参数分隔之后的数组
        if (typeof roleNamesString != 'string') throw Error('rolename must be a string!');
        if (roleNamesString.indexOf(',') > 0) roleNameArr = roleNamesString.split(',');
        else roleNameArr.push(roleNamesString);
        var flag = false;
        for (var j = 0; j < roleNameArr.length; j++) {
            if (flag == true) break;
            var roleName = roleNameArr[j];
            for (var i = 0; i < cachedRoleNameArray.length; i++) {
                var cachedRole = cachedRoleNameArray[i];
                if (roleName === cachedRole) {
                    flag = true;
                    break;
                }
            }
        }
        return flag;
    }

    this.SelectForm = function (_RoleNamesCache) {
        if ((window.IsUSD != null) && (window.IsUSD == true)) {
            var item = Xrm.Page.ui.formSelector.getCurrentItem();
            if (item != null) {
                if (item.getId().toUpperCase() != "F77F758F-7B78-4BB4-9E26-50A8ED05843E") {
                    var items = Xrm.Page.ui.formSelector.items;
                    items.forEach(function (itemss, i) {
                        if (itemss.getId().toUpperCase() == "F77F758F-7B78-4BB4-9E26-50A8ED05843E") {

                            itemss.navigate();
                        }
                    });
                }
            }
        }
        else {
            if (CRM.Common.IsUserHasRolesInCached('CHM,CHM-TL,HSM,QA,SCR,TSR', _RoleNamesCache) == true) {
                var item = Xrm.Page.ui.formSelector.getCurrentItem();
                if (item != null) {
                    if (item.getId().toLocaleUpperCase() != "ACEC9DC8-99A5-495B-9FB6-2D90188DF52A") {
                        var items = Xrm.Page.ui.formSelector.items;
                        items.forEach(function (itemss, i) {
                            if (itemss.getId().toLocaleUpperCase() == "ACEC9DC8-99A5-495B-9FB6-2D90188DF52A") {
                                itemss.navigate();
                            }
                        });
                    }
                }
            }
            else if (CRM.Common.IsUserHasRolesInCached('TSE,TSE-TL', _RoleNamesCache) == true) {
                var item = Xrm.Page.ui.formSelector.getCurrentItem();
                if (item != null) {
                    if (item.getId().toLocaleUpperCase() != "E7257A45-AB99-40EF-A662-A06727CAFB00") {
                        var items = Xrm.Page.ui.formSelector.items;
                        items.forEach(function (itemss, i) {
                            if (itemss.getId().toLocaleUpperCase() == "E7257A45-AB99-40EF-A662-A06727CAFB00") {
                                itemss.navigate();
                            }
                        });
                    }
                }
            }
            else {
                var item = Xrm.Page.ui.formSelector.getCurrentItem();
                if (item != null) {
                    if (item.getId().toUpperCase() != "6A821E32-7EBC-44D9-9128-DCFEBB10E4C3") {
                        var items = Xrm.Page.ui.formSelector.items;
                        items.forEach(function (itemss, i) {
                            if (itemss.getId().toUpperCase() == "6A821E32-7EBC-44D9-9128-DCFEBB10E4C3") {
                                itemss.navigate();
                            }
                        });
                    }
                }
            }
        }

        if (item == null) {
            Xrm.Page.ui.formSelector.items.get(0).navigate();
        }
    };

    //邮箱的正则表达式验证 created by kevinchow 2017/11/10
    this.EMailCheck = function (ExecutionContextObj) {
        var checkString = new RegExp(/^[a-zA-Z0-9]+([._\\-]*[a-zA-Z0-9])*@([a-zA-Z0-9]+[-a-zA-Z0-9]*[a-zA-Z0-9]+.){1,63}[a-zA-Z0-9]+$/);
        var attribute = ExecutionContextObj.getEventSource().getName();
        var _email = Xrm.Page.getAttribute(attribute).getValue();
        if (_email != null && _email != '' && !checkString.test(_email.trim())) {
            var errMsg = CRM.Common.getLocalizedStringByKey('common_checkemailformat');
            Xrm.Page.getControl(attribute).setNotification(errMsg, "98EE9784-BADE-470A-8B67-MDZ05A013AB1");
            return;
        }
        else {
            Xrm.Page.getControl(attribute).clearNotification("98EE9784-BADE-470A-8B67-MDZ05A013AB1");
        }
    };


    //客服操作FAQ AaronLee 2018/04/28
    this.opCustomerOperationFAQ = function (param) {
        var url = "";
        if (param == 0) {
            url = "http://consumer-tkb.huawei.com/ctkb/home.html#/index/knowledgeDtails/29011bf7-483d-11e8-8273-286ed48999eb/zh-cn";
        }
        else {
            url = "http://consumer-tkb.huawei.com/ctkb/home.html#/index/knowledgeDtails/856147d3-3ba3-11e8-8273-286ed48999eb/en-us";
        }
        window.open(url);
    }

    //门店操作FAQ AaronLee 2018/04/28
    this.opCscOperationFAQ = function (param) {
        var url = "";
        if (param == 0) {
            url = "http://consumer-tkb.huawei.com/ctkb/home.html#/index/knowledgeDtails/24e29472-483d-11e8-8273-286ed48999eb/zh-cn";
        }
        else {
            url = "http://consumer-tkb.huawei.com/ctkb/home.html#/index/knowledgeDtails/ec8bdc1b-3f02-11e8-8273-286ed48999eb/en-us";
        }
        window.open(url);
    }

    this.getId = function (id) {
        return id.replace("{", "").replace("}", "").toLowerCase();
    }
    //根据页面其他查找字段设置查找字段筛选条件
    this.preSearchByLinkAttribute = function (linkAttributeName, filterAttributeName, lookUpControlName) {
        /// <param name="linkAttributeName" type="String">条件查找字段名</param>
        /// <param name="filterAttributeName" type="String">筛选条件属性名</param>
        /// <param name="lookUpControlName" type="function">目标查找控件名</param>
        //参数示例： "mcs_warehouse", "mcs_warehouse", "mcs_storagearea"
        var linkControlValue = Xrm.Page.getAttribute(linkAttributeName).getValue();
        var strFetch = "";
        if (linkControlValue != null) {
            strFetch = '<filter type="and"><condition attribute="' + filterAttributeName + '" operator="eq" value="' +
                linkControlValue[0].id +
                '" /></filter>';
        }
        Xrm.Page.getControl(lookUpControlName).addCustomFilter(strFetch);
    }
    //固定条件设置查找字段筛选条件
    this.preSearchByAttribute = function (filterAttributeName, filterAttributeValue, lookUpControlName) {
        /// <param name="filterAttributeName" type="String">筛选条件属性名 </param>
        /// <param name="filterAttributeValue" type="String">筛选条件属性值</param>
        /// <param name="lookUpControlName" type="function">目标查找控件名</param>
        //参数示例： "mcs_vdcinventorystatus", 3, "mcs_vin"
        var strFetch = '<filter type="and"><condition attribute="' + filterAttributeName + '" operator="eq" value="' +
            filterAttributeValue + '" /></filter>';
        Xrm.Page.getControl(lookUpControlName).addCustomFilter(strFetch);
    }
    //固定条件设置查找字段筛选条件
    this.preSearchByAttributes = function (filterList, lookUpControlName) {
        /// <param name="filterList" type="String">筛选条件数组 </param>
        /// <param name="lookUpControlName" type="function">目标查找控件名</param>
        //参数示例： [{name:"mcs_islocked",value:"false"},{name:"mcs_isoccupy",value:"false"}], "mcs_vin"
      var strCondition = filterList.forEach(function (item) {
            strCondition += '<condition attribute="' + item["name"] + '" operator="eq" value="' + item["value"] + '" />';
        });
        var strFetch = '<filter type="and">' + strCondition + '</filter>';
        Xrm.Page.getControl(lookUpControlName).addCustomFilter(strFetch);
    }
    //获取用户并返回窗体lookup字段值
    this.getUserLookUpFormatValue = function() {
        ///
        var context = this.getContext();
        return [
            {
                id: this.getId(context.getUserId()),
                entityType: "systemuser",
                name: context.getUserName()
            }
        ];
    }
}).call(CRM.Common);
Date.prototype.format = function (fmt) {
    ///<summary>
    /// 将日期时间进行格式化
    ///</summary>
    ///<param name="name" type="Date">
    /// 要格式化的日期时间
    ///</param>
    var o = {
        "M+": this.getMonth() + 1,//月份   
        "d+": this.getDate(),//日   
        "h+": this.getHours(),//小时   
        "m+": this.getMinutes(),//分   
        "s+": this.getSeconds()//秒     
    };
    if (/(y+)/.test(fmt))
        fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
    for (var k in o)
        if (new RegExp("(" + k + ")").test(fmt))
            fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ?
                (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
    return fmt;
};

Date.prototype.formatUTC = function (fmt) {
    ///<summary>
    /// 将日期时间转换为UTC标准时间后进行格式化
    ///</summary>
    ///<param name="name" type="Date">
    /// 要格式化的日期时间
    ///</param>
    var o = {
        "M+": this.getUTCMonth() + 1,//月份   
        "d+": this.getUTCDate(),//日   
        "h+": this.getUTCHours(),//小时   
        "m+": this.getUTCMinutes(),//分   
        "s+": this.getUTCSeconds()//秒  
    };
    if (/(y+)/.test(fmt))
        fmt = fmt.replace(RegExp.$1, (this.getUTCFullYear() + "").substr(4 - RegExp.$1.length));
    for (var k in o)
        if (new RegExp("(" + k + ")").test(fmt))
            fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ?
                (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
    return fmt;
};

String.prototype.Format = function () {
    var args = arguments;
    return this.replace(/\{(\d+)\}/g, function (m, i) {
        return args[i];
    });
};