function utf8_to_b64(str) {
    return window.btoa(unescape(encodeURIComponent(str)));
}

function b64_to_utf8(str) {
    return decodeURIComponent(escape(window.atob(str)));
}


//获取版本号相关信息
function netca_checkServiceOK(SuccessCallBack,FailedCallBack)
{
	var NETCA_ERROR_WEBSOCKETCONNECTFAIL=-11000;
	var params ={};
	NetcaPKI.CheckLocalServerOk(params)
	    .Then(function(res)
		{          
			SuccessCallBack();
			
        })
        .Catch(function (res) 
		{           
			 if(res.status==NETCA_ERROR_WEBSOCKETCONNECTFAIL)
            {

				//连接失败 返回错误 其他错误认为是成功
			    FailedCallBack();
			}
			else
			{
				SuccessCallBack();
			}
        });	
}

/* 非对称加密，加密文件内容
 selectType，选择证书的来源
 selectCondition，选择证书的条件，
publicKeyEncFilePath,要加密的文件路径
 */
function netca_publicKeyEncryptFile(selectType,selectCondition,publicKeyEncFilePath,SuccessPublicKeyEncryptFileCallBack,FailedPublicKeyEncryptFileCallBack)
{
	var params = {
        cert: { //证书(CertificateParams)           
            type: selectType,
            condition: selectCondition
        },        
        data: { //数据(DataParams)           
            fileName: publicKeyEncFilePath
        }
	}
    NetcaPKI.publicKeyEncrypt(params)
        .Then(function (res) {
            publicKeyEncResult.value = res.encryptValue;
            lastPublicKeyEncResult.value = res.encryptValue;
        })
        .Catch(function (res) {
            alert(res.msg);
        })
}

/* 非对称加密，加密文本
 selectType，选择证书的来源
 selectCondition，选择证书的条件，
tbs,要加密的文本 
 */
function netca_publicKeyEncryptText(selectType,selectCondition,tbs,SuccessPublicKeyEncryptFileCallBack,FailedPublicKeyEncryptFileCallBack)
{
	var params = {
        cert: { //证书(CertificateParams)           
            type: selectType,
            condition: selectCondition
        },        
        data: { //数据(DataParams)           
            text: tbs
	}};
    NetcaPKI.publicKeyEncrypt(params)
        .Then(function (res) {
            SuccessPublicKeyEncryptFileCallBack(res);            
        })
        .Catch(function (res) {
            FailedPublicKeyEncryptFileCallBack(res);
        })
}

/* 非对称解密
 selectType，选择证书的来源
 selectCondition，选择证书的条件，
cipherData,要解密的密文 
savefile,解密后如果需要使用文件保存，传入的文件路径,如果为null，则不使用文件保存
 */
function netca_privateKeyDecrypt(selectType,selectCondition,cipherData,savefile,SuccessPrivateKeyDecryptCallBack,FailedPrivateKeyDecryptCallBack)
{
    var params = {
        cert: {
            type: selectType,
            condition: selectCondition
        },
        // algo: 0, //非对称加密算法
        encData: cipherData,
		savefileName:savefile
    };
    NetcaPKI.privateKeyDecrypt(params)
        .Then(function (res) {
            SuccessPrivateKeyDecryptCallBack(res);
        })
        .Catch(function (res) {
           FailedPrivateKeyDecryptCallBack(res);
        })
}

/* signedData签名
certEncode, 证书编码，如果为空字符串，则使用selectType,和selectCondition构造的条件选择证书
 selectType，certEncode为空时，使用该项选择证书
 selectCondition，certEncode为空时，使用该项选择证书，
 tbs,要签名的明文 
 _useSubjectKeyId：是否使用密钥标识符
 _useQ7：是否使用主体密钥标识符来标识证书，默认为true
 _detached：整数	是否不带原文，默认为0
 _tsaURL：时间戳url
 _includeCertOption//整数	包含证书的标识
 */
function netca_signedDataSign(certEncode,selectType,selectCondition,tbs,_useSubjectKeyId,_useQ7,_tsaURL,_detached,_includeCertOption,_certPwd,SuccessSignedDataSignCallBack,FailedSignedDataSignCallBack)
{
		var params={};
		if(_certPwd=="")
		{
			params = {
				cert: { //证书(CertificateParams)
				encode: certEncode, //可选字段但不能为空
				type: selectType,
				condition: selectCondition
			},     
			data: { //数据(DataParams)
				text: tbs,
				encodeType:0
			},
			useSubjectKeyId: _useSubjectKeyId, //是否使用主体密钥标识符来标识证书，默认为true
			useQ7:_useQ7, //布尔值	是否使用国密Q7的方式，默认为false
			detached: parseInt(_detached), //整数	是否不带原文，默认为0
			tsaURL: _tsaURL,
			includeCertOption: _includeCertOption//整数	包含证书的标识       
		};			
		}else
		{
			params = {
				cert: { //证书(CertificateParams)
				encode: certEncode, //可选字段但不能为空
				type: selectType,
				condition: selectCondition
				},     
				data: { //数据(DataParams)
				text: tbs,
				encodeType:0
				},
				useSubjectKeyId: _useSubjectKeyId, //是否使用主体密钥标识符来标识证书，默认为true
				useQ7:_useQ7, //布尔值	是否使用国密Q7的方式，默认为false
				detached: parseInt(_detached), //整数	是否不带原文，默认为0
				tsaURL: _tsaURL,
				includeCertOption: _includeCertOption,//整数	包含证书的标识
				certPwd:_certPwd
			};			
		}		
    NetcaPKI.signedDataSign(params)
        .Then(function (res) {
			if(res.result==-5)
			{
					FailedSignedDataSignCallBack(res);
			}
			else
			{
					SuccessSignedDataSignCallBack(res); 
			}
          
        })
        .Catch(function (res) {
            FailedSignedDataSignCallBack(res);
        })
	
}

/* signedData验证
verifyLevel, 验证级别
signValue：base64编码的签名值
 tbs：base64编码后的明文 
 */

function netca_signedDataVerify(verifyLevel,signValue,tbs,SuccessSignedDataVerifyCallBack,FailedSignedDataVerifyCallBack)
{
    var params = {
        verifyLevel: verifyLevel, //验证级别，默认为验证签名本身，不验证证书，默认为1
        signedData: signValue //signedData的编码值
    };
    if (tbs != null) {
        params.originData = {
            text: tbs
        };
    }
    NetcaPKI.signedDataVerify(params)
        .Then(function (res) {
            SuccessSignedDataVerifyCallBack(res);
        })
        .Catch(function (res) {
            FailedSignedDataVerifyCallBack(res);
        })
}

/* 数字信封加密---加密文件内容
certEncode, 证书编码，如果为空字符串，则使用selectType,和selectCondition构造的条件选择证书
 selectType，certEncode为空时，使用该项选择证书
 selectCondition，certEncode为空时，使用该项选择证书，
 _fieldName,明文文件路径
 _algo,使用的对称加密算法，默认为AES 128 CBC模式
 */

function netca_envelopedDataEncryptFile(certCode,selectType,selectCondition,_fieldName,_algo,SuccessEnvelopedDataEncryptCallBack,FailedEnvelopedDataEncryptCallBack) {
    

    var params = {
        cert: { //证书(CertificateParams)
            encode: certCode,
            type: selectType,
            condition: selectCondition
        },
        algo : _algo, //对称加密算法，默认为128位的AES CBC模式
        data: {
			fileName: _fieldName
		}
    };
   NetcaPKI.envelopedDataEncrypt(params)
        .Then(function (res) {
           SuccessEnvelopedDataEncryptCallBack(res);
        })
        .Catch(function (res) {
            FailedEnvelopedDataEncryptCallBack(res);
        })
}




/* 数字信封加密---加密文本
certEncode, 证书编码，如果为空字符串，则使用selectType,和selectCondition构造的条件选择证书
 selectType，certEncode为空时，使用该项选择证书
 selectCondition，certEncode为空时，使用该项选择证书，
 clearText,明文字符串
 _algo,使用的对称加密算法，默认为AES 128 CBC模式
 SuccessEnvelopedDataEncryptCallBack，加密成功时回调接口
 FailedEnvelopedDataEncryptCallBack，加密失败时回调接口

 */

function netca_envelopedDataEncryptText(certCode,selectType,selectCondition,clearText,_algo,SuccessEnvelopedDataEncryptCallBack,FailedEnvelopedDataEncryptCallBack) {
  
       
    var params = {
        cert: { //证书(CertificateParams)
            encode: certCode,
            type: selectType,
            condition: selectCondition
        },
        algo : _algo, //对称加密算法，默认为128位的AES CBC模式
        data: {
			text: clearText
		}
    };
    NetcaPKI.envelopedDataEncrypt(params)
        .Then(function (res) {
           SuccessEnvelopedDataEncryptCallBack(res);
        })
        .Catch(function (res) {
            FailedEnvelopedDataEncryptCallBack(res);
        })
}


/* 解密数字信封
encData,数字信封编码
saveFile,解密后如果需要使用文件保存，传入的文件路径,如果为null，则不使用文件保存
SuccessEnvDecryptCallBack，解密成功时执行的回调函数
FailedEnvDecryptCallBack，解密失败时执行的回调函数
*/

function netca_envelopedDataDecrypt(encData,saveFile,SuccessEnvDecryptCallBack,FailedEnvDecryptCallBack) {
    var params = {
        encData: encData, //要解密的数据
		savefileName:saveFile
    };
    NetcaPKI.envelopedDataDecrypt(params)
        .Then(function (res) {
			SuccessEnvDecryptCallBack(res);
        })
        .Catch(function (res) {
            FailedEnvDecryptCallBack(res);
        })
}

function netca_AutoSignField(_hashAlgo,src_File,dest_File,revInfoInclude,_tsaURL,_tsaUsr,_tsaPwd,_tsaHashAlgo,_allowCertType,_selMode,
                                _fieldName,SignSuccessCallBack,SignFailedCallBack) {
    var params = {
        hashAlgo: _hashAlgo, //例如：“sha-1”，“sha-256”
        srcFile: src_File, //源pdf文件
        destFile: dest_File, //源pdf文件
        revInfoIncludeFlag: revInfoInclude, //签名时是否包含签名证书状态信息，true包含
        selMode: _selMode, //选择模式，有两种：按证书选择（0）和按印章选择（1）
        tsaURL: _tsaURL, //时间戳地址
        tsaUsr: _tsaUsr, //时间戳服务对应用户名
        tsaPwd:_tsaPwd, //时间戳服务对应用户的密码
        tsaHashAlgo: _tsaHashAlgo, //时间戳使用的hash算法，例如”sha-1”，”sha-256”等
        allowCertType: _allowCertType,
        /**
         * allowCertType为NULL或者ANY表示不进行限制。
         * RSA为RSA类型，SM2为SM2类型，ECC为ECC类型包括SM2，ECC!SM2为不包括SM2的ECC类型。
         * RSA:SM2为既包括RSA也包括SM2。
         * 默认支持RSA,SM2类型的证书。
         * 中间件 5.2版本新增的
         */
     
        signField: {
            fieldName: _fieldName //要进行签名的签名域名称
        }
    };
    NetcaPKI.pdfAutoSign(params)
        .Then(function (res) {
           SignSuccessCallBack();
        })
        .Catch(function (res) {
           SignFailedCallBack(res);
        });;
}




function netca_AutoSignPosition(_hashAlgo,src_File,dest_File,revInfoInclude,_tsaURL,_tsaUsr,_tsaPwd,_tsaHashAlgo,_allowCertType,_selMode,
                                _pdfSign_pageNumber,_pdfSign_xpos,_pdfSign_ypos,_pdfSign_seal_width,_pdfSign_seal_height,
								 SignSuccessCallBack,SignFailedCallBack) {
    var params = {
        hashAlgo: _hashAlgo, //例如：“sha-1”，“sha-256”
        srcFile: src_File, //源pdf文件
        destFile: dest_File, //源pdf文件
        revInfoIncludeFlag: revInfoInclude, //签名时是否包含签名证书状态信息，true包含
        selMode: _selMode, //选择模式，有两种：按证书选择（0）和按印章选择（1）
        tsaURL: _tsaURL, //时间戳地址
        tsaUsr: _tsaUsr, //时间戳服务对应用户名
        tsaPwd:_tsaPwd, //时间戳服务对应用户的密码
        tsaHashAlgo: _tsaHashAlgo, //时间戳使用的hash算法，例如”sha-1”，”sha-256”等
        allowCertType: _allowCertType,
        /**
         * allowCertType为NULL或者ANY表示不进行限制。
         * RSA为RSA类型，SM2为SM2类型，ECC为ECC类型包括SM2，ECC!SM2为不包括SM2的ECC类型。
         * RSA:SM2为既包括RSA也包括SM2。
         * 默认支持RSA,SM2类型的证书。
         * 中间件 5.2版本新增的
         */
        signPosition: {
            pageNum: parseInt(_pdfSign_pageNumber), //输入参数，整型，PDF文档的页码，页码从1开始计算。
            xPos: parseInt(_pdfSign_xpos), //输入参数，整型，签章左下角的水平向右方向坐标。
            yPos: parseInt(_pdfSign_ypos), //输入参数，整型，签章左下角的垂直向上方向坐标。
            width: parseInt(_pdfSign_seal_width), //输入参数，整型，签章的宽度。
            height: parseInt(_pdfSign_seal_height) //输入参数，整型，签章的高度。
        }
    };
    NetcaPKI.pdfAutoSign(params)
        .Then(function (res) {
           SignSuccessCallBack();
        })
        .Catch(function (res) {
            SignFailedCallBack(res);
        });
}




/*
 获取证书或证书属性
 certEncode, 证书编码，如果为空字符串，则使用selectType,和selectCondition构造的条件选择证书
 selectType，certEncode为空时，使用该项选择证书
 selectCondition，certEncode为空时，使用该项选择证书，
 attId，证书属性
 successCallBack，成功时执行的回调函数
 failedCallBack，失败时执行的回调函数
 */
 
 /* 从USBKey中选择NETCA 颁发的签名证书
   var selectType = "{\"UIFlag\":\"default\", \"InValidity\":true,\"Type\":\"signature\", \"Method\":\"device\",\"Value\":\"any\"}";
   var selectCondition = "IssuerCN~'NETCA' && InValidity='True' && CertType='Signature'";
*/

 /* 从微软证书库中选择NETCA 颁发的加密证书 

        var selectType = "{\"UIFlag\":\"default\",\"Type\":\"encrypt\",\"Method\":\"store\", \"Value\":{\"Type\":\"current user\",\"Value\":\"my\"}}";
        var selectCondition = "IssuerCN~'NETCA' && CertType='Encrypt'";
*/
		
function netca_getCertStringAttribute(certEncode,selectType,selectCondition,attId,successCallBack,failedCallBack)
{
	var params = {
		 cert: {
           "encode":certEncode,
		   "type":selectType,
		   "condition":selectCondition
		   },
		   id:parseInt(attId)
		};
	NetcaPKI.getCertStringAttribute(params)
	    .Then(function(res){
			successCallBack(res);
        })
        .Catch(function (res) {
           failedCallBack(res);
        });;
}


/*
 *判断指定设备的是否插入
 certEncode,证书编码，可为空字符串，表示判断证书所在的设备是否插入
 keySN,设备序列号，可为空，表示判断设备序列号为KeySN的设备是否插入
 keyType,设备类型，可为-1，表示判断设备类型为keyType的设备是否插入
 certEncode，keySN，keyType 都设置时，三者之间的关系为交集，即判断设备设备序列号为
 keySN,设备类型为keyType,且包含证书certEncode的设备是否插入。
 都不设置时，判断任何一个Key是否插入。
 InsertCallBack,有插入设备时执行的回调函数
 UnInsertCallBack，无插入的设备时执行的回调函数
 */
function netca_isInsertKey(certEncode,keySN,keyType,InsertCallBack,UnInsertCallBack)
{
	var params = {
		 cert: {
           "encode":certEncode 
		   },//可选,指定证书所在的Key是否插入
		 sn:keySN, //可选
		 type:parseInt(keyType) //可选
		};
	NetcaPKI.isInsertKey(params)
	    .Then(function(res){
			
			if (res.insertCount > 0)
			{
				InsertCallBack(res);
			}
			else
			{
				UnInsertCallBack(res);
				
			}

        })
        .Catch(function (res) {
        UnInsertCallBack(res);
        });;
}



function netca_Custom_PdfSignAndUpload(certEncode,pageNum,x,y,signPdfBase64Str,UploadPdfUrl,successCallBack,failedCallBack)
{
	var params = {
		 
           "certEncode":certEncode,
		   "pageNum":pageNum,
		   "x":x,
			"y":y,
			 "signPdfBytes":signPdfBase64Str,
			   "uploadPdfUrl":UploadPdfUrl
		   
		};
	NetcaPKI.Custom_PdfSignAndUpload(params)
	    .Then(function(res){
			successCallBack(res);
        })
        .Catch(function (res) {
           failedCallBack(res);
        });;
}

function  netca_Custom_PdfSignAndUploadURL(certEncode,pageNum,x,y,width,height,signUrl,UploadPdfUrl,successCallBack,failedCallBack)
{  
//signPdfUrl
var params = {
		 
           "certEncode":certEncode,
		   "pageNum":pageNum,
		   "x":x,
			"y":y,
			"width":width,
			"height":height,
			 "signPdfUrl":signUrl,
			   "uploadPdfUrl":UploadPdfUrl
		   
		};
	NetcaPKI.Custom_PdfSignAndUploadByURL(params)
	    .Then(function(res){
			successCallBack(res);
        })
        .Catch(function (res) {
           failedCallBack(res);
        });;
}
 
//获取签章
//参数是证书编码
function netca_getSealImage(certEncode, SuccessGetSealImageCallBack, FailedGetSealImageCallBack) {


    var params = {
        cert: {
            "encode": certEncode
        }
    };

 
    NetcaPKI.GetNetcaSealImage(params)
	    .Then(function (res) {
	        SuccessGetSealImageCallBack(res);
	    })
        .Catch(function (res) {
            FailedGetSealImageCallBack(res);
        });
}


/*
 *验证指定设备的密码
 password,介质密码，可为空字符串，则由底层弹出密码输入框
 certEncode,证书编码，可为空字符串，表示验证证书所在的Key的密码
 keySN,设备序列号，可为空，表示验证设备序列号为KeySN的设备的密码
 keyType,设备类型，可为-1，表示验证设备类型为keyType的设备的密码，
 certEncode，keySN，keyType 都设置时，三者之间的关系为交集，即验证的设备是设备序列号为
 keySN,设备类型为keyType,且包含证书certEncode.
 都不设置时, 默认验证第一个设备的PIN码
  SuccessCallBack，成功时执行的回调函数
 FailedCallBack，失败时执行的回调函数
 */
function netca_verifyKeyPwd(password,certEncode,keySN,keyType,SuccessCallBack,FailedCallBack)
{
		
	var params = {
		pwd:password,
		 cert: {
           "encode":certEncode 
		   },//可选,指定证书所在的Key是否插入
		 sn:keySN, //可选
		 type:parseInt(keyType) //可选
		};
		
	NetcaPKI.verifyKeyPwd(params)
	    .Then(function(res){
			if (res.result == 1)
			{
				var tip = "密码验证成功，验证的设备类型为 " + res.type + 
				";  验证的设备序列号为 " + res.sn 
				+ ";  密码剩余重试次数为 " + res.retrynum;
				
				SuccessCallBack(res);
			}
			else
			{
				var tip = "密码验证失败，错误码为" + res.result + 
				";  验证的设备类型为 " + res.type + 
				";  验证的设备序列号为 " + res.sn 
				+ ";  密码剩余重试次数为 " + res.retrynum;
				
				FailedCallBack(res);
			}

        })
        .Catch(function (res) {
            alert(res.msg);			
        });;
}


function netca_getCertStringExtensionValue(certEncode,selectType,selectCondition,oidString,oidType,SuccessCallBack,FailedCallBack)
{
       var params = {
          cert: {
           "encode":certEncode,
		   "type":selectType,
		   "condition":selectCondition
		   },
		   oidstr:oidString,
			type: oidType
		};

	 
		NetcaPKI.GetCertStringExtensionValue(params)
			.Then(function (res) {
				SuccessCallBack(res);
			})
			.Catch(function (res) {
				FailedCallBack(res);
			});
   
}


//获取版本号相关信息
function netca_getVersionInfo(SuccessGetVersionInfoCallBack,FailedGetVersionInfoCallBack)
{
	
	var params ={};
	NetcaPKI.getVersionInfo(params)
	    .Then(function(res)
		{
			SuccessGetVersionInfoCallBack(res);
        })
        .Catch(function (res) 
		{            
			FailedGetVersionInfoCallBack(res);
        });	
}


//获取客户端KeyX版本号相关信息
function netca_getClientVersionInfo(SuccessGetVersionInfoCallBack, FailedGetVersionInfoCallBack) {

    var params = {};
    NetcaPKI.getClientVersionInfo(params)
	    .Then(function (res) {
	        SuccessGetVersionInfoCallBack(res);
	    })
        .Catch(function (res) {
            FailedGetVersionInfoCallBack(res);
        });
}


//监控设备插拔
function netca_monitorDevice(_delayTime,SuccessMonitorDeviceCallBack,FailedMonitorDeviceCallBack)
{
	
	var params = {
        delayTime: _delayTime //延迟时间，默认为0毫秒
    };
	NetcaPKI.monitorDevice(params)
	    .Then(function(res)
		{
			SuccessMonitorDeviceCallBack(res);
        })
        .Catch(function (res) 
		{            
			FailedMonitorDeviceCallBack(res);
        });
}



//PKCS#1签名
//version >=1.4.1
/*
参数说明:
 certEncode, 证书编码，如果为空字符串，则使用selectType,和selectCondition构造的条件选择证书
 selectType，certEncode为空时，使用该项选择证书
 selectCondition，certEncode为空时，使用该项选择证书
 signAlgo，  签名算法 整数 SHA256WthRSA签名算法为4,SM3WithSM2签名算法为25 参考NETCA Crypto API 文档
 origindata base64编码字符串 ，待签名的数据
 SuccessSignCallBack，成功时执行的回调函数
 FailedSignCallBack，失败时执行的回调函数
 */
function netca_sign(certEncode, selectType, selectCondition,signAlgo,origindata, SuccessSignCallBack, FailedSignCallBack) {

    var params = {
        cert: {
            "encode": certEncode,
            "type": selectType,
            "condition": selectCondition
        },
        data: {
            text: origindata
        },
        algo: signAlgo
    };
    NetcaPKI.sign(params)
	    .Then(function (res) {
	        SuccessSignCallBack(res);
	    })
        .Catch(function (res) {
            FailedSignCallBack(res);
        });
}

//PKCS#1签名
//version >=1.4.1
/*

 certEncode,字符串, 证书编码，如果为空字符串，则使用selectType,和selectCondition构造的条件选择证书
 selectType，certEncode为空时，使用该项选择证书
 selectCondition，certEncode为空时，使用该项选择证书，
 origindata ，字符串 base64编码,原签名数据
 signAlgo，签名算法 SHA256WthRSA签名算法为4,SM3WithSM2签名算法为25 参考NETCA Crypto API 文档
 SuccessSignVerifyCallBack，成功时执行的回调函数
 FailedSignVerifyCallBack，失败时执行的回调函数
 */
function netca_verifySignature(certEncode, selectType, selectCondition, signAlgo, origindata, signValue, SuccessSignVerifyCallBack, FailedSignVerifyCallBack) {

    var params = {
        cert: {
            "encode": certEncode,
            "type": selectType,
            "condition": selectCondition
        },
        data: {         
            text: origindata
        },
        signature:signValue,
        algo: signAlgo
    };
    NetcaPKI.verifySignature(params)
	    .Then(function (res) {
	        SuccessSignVerifyCallBack(res);
	    })
        .Catch(function (res) {
            FailedSignVerifyCallBack(res);
        });
}

//////////////工具函数///////////////////

function JsonToTable(json) {
    for (var key in json) {

    }
}

function toggleVisible(dom) {
    toggleClassName(dom.parentElement.getElementsByTagName('table')[0], 'hide');
}
//移除类名
function removeClass(dom, className) {
    var temp = dom.className.split(' ');
    dom.className = "";
    for (var index in temp) {
        if (temp[index] != className) {
            dom.className += (temp[index] + ' ');
        }
    }
}
//添加类名
function addClass(dom, className) {
    if (dom.className != "") {
        if (!hasClass(dom, className)) {
            dom.className += (' ' + className);
        }
    } else {
        dom.className = className;
    }
}

//是否含有此类名
function hasClass(dom, className) {
    var classNames = dom.className.split(' ');
    for (var index in classNames) {
        if (classNames[index] == className) {
            return true;
        }
    }
    return false;
}

function toggleClassName(dom, className) {
    if (hasClass(dom, className)) {
        removeClass(dom, className);
    } else {
        addClass(dom, className);
    }
}

function toggleBlock(className, showElementId) {
    var collection = document.getElementsByTagName('*');
    for (var index = 0; index < collection.length; index++) {
        if (hasClass(collection[index], className)) {
            addClass(collection[index], 'hide');
        }
    }
    var showElement = document.getElementById(showElementId);
    removeClass(showElement, 'hide');
}

function formatPrint(outValue){
	if(outValue == null || outValue == undefined || outValue.length == 0)
		return "null";
	else 
		return outValue;
}


//获取硬件信息，包括
function netca_getHardDeviceInformation(SuccessGetCallBack,FailedGetCallBack)
{
	
	var params ={};
	NetcaPKI.getHardDeviceInformation(params)
	    .Then(function(res)
		{
			SuccessGetCallBack(res);
        })
        .Catch(function (res) 
		{            
			FailedGetCallBack(res);
        });	
}

//获取网络信息
function netca_getNetworkInformation(SuccessGetCallBack, FailedGetCallBack)
{
    var params = {};
    NetcaPKI.getNetworkInformation(params)
        .Then(function(res)
        {
            SuccessGetCallBack(res);
        })
        .Catch(function(res)
        {
            FailedGetCallBack(res);
        });
}


//标准签名/签章接口
/*通过查找符合条件的证书，
解析源文件和PDF字节流，
可在指定页面指定位置，定位签名或签章，
可在已有域进行签名或签章，
并将结果保存到目标文件中。
 */
function netca_SignatureCreator_PdfSignSealField(_srcFile, _srcBytes, _destFile, _certEncode, _selMode, 
    _signFieldText, _sealImageEncode, _fieldName, _tsaUrl, _tsaUsr, _tsaPwd, _tsaHashAlgo, 
    _SignatureCreatorSuccessCallBack, _SignatureCreatorFailedCallBack)
{
    var params = {
        srcFile: _srcFile,                      //源pdf文件
        srcBytes: _srcBytes,                    //源Pdf文件的Base64编码
        destFile: _destFile,                    //目标pdf文件
        certEncode: _certEncode,                //签名证书Base64编码
        selMode: _selMode,                      //操作模式
        signFieldText: _signFieldText,          //签名域显示的文字
        sealImageEncode: _sealImageEncode,      //签章图片Base64编码
        SignField:                              //签名域对象
        {
            fieldName: _fieldName              //签名域名称
        }, 
        Tsa:                                    //时间戳对象
        {
            tsaUrl: _tsaUrl,                    //时间戳地址
            tsaUsr: _tsaUsr,                    //时间戳服务对应用户名
            tsaPwd: _tsaPwd,                    //时间戳服务对应用户的密码
            tsaHashAlgo: _tsaHashAlgo           //时间戳使用的hash算法，例如”sha-1”，”sha-256”等
        }
    };
    NetcaPKI.SignatureCreatorPdfSignSealFieldOrPosition(params)
        .Then(function (res)
        {
            _SignatureCreatorSuccessCallBack(res);
        })
        .Catch(function (res)
        {
            _SignatureCreatorFailedCallBack(res);
        });
}
function netca_SignatureCreator_PdfSignSealPosition(_srcFile, _srcBytes, _destFile, _certEncode, _selMode, 
    _signFieldText, _sealImageEncode, _pageNum, _xPos, _yPos, _width, _height, 
    _tsaUrl, _tsaUsr, _tsaPwd, _tsaHashAlgo, _SignatureCreatorSuccessCallBack, _SignatureCreatorFailedCallBack)
{
    var params = {
        srcFile: _srcFile,                      //源pdf文件
        srcBytes: _srcBytes,                    //源Pdf文件的Base64编码
        destFile: _destFile,                    //目标pdf文件
        certEncode: _certEncode,                //签名证书Base64编码
        selMode: _selMode,                      //操作模式
        signFieldText: _signFieldText,          //签名域显示的文字
        sealImageEncode: _sealImageEncode,      //签章图片Base64编码
        SignPosition:                           //签名位置对象
        {
            pageNum: _pageNum,                  //PDF文档的页码
            xPos: _xPos,                        //签名域/签章左下角的水平向右方向坐标
            yPos: _yPos,                        //签名域/签章左下角的垂直向上方向坐标
            width: _width,                      //签名域/签章的宽度
            height: _height                    //签名域/签章的高度
        }, 
        Tsa:                                    //时间戳对象
        {
            tsaUrl: _tsaUrl,                    //时间戳地址
            tsaUsr: _tsaUsr,                    //时间戳服务对应用户名
            tsaPwd: _tsaPwd,                    //时间戳服务对应用户的密码
            tsaHashAlgo: _tsaHashAlgo           //时间戳使用的hash算法，例如”sha-1”，”sha-256”等
        }
    };
    NetcaPKI.SignatureCreatorPdfSignSealFieldOrPosition(params)
        .Then(function (res)
        {
            _SignatureCreatorSuccessCallBack(res);
        })
        .Catch(function (res)
        {
            _SignatureCreatorFailedCallBack(res);
        });
}

function netca_GetNetcaSealImage(certEncode,successCallBack,failedCallBack)
{
	var params = {
           "cert":{
			   "encode":certEncode
		   }
		};
	NetcaPKI.GetNetcaSealImage(params)
	    .Then(function(res){
			successCallBack(res);
        })
        .Catch(function (res) {
           failedCallBack(res);
        });;
}