/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  org.apache.commons.beanutils.BeanUtils
 *  org.apache.commons.lang.StringUtils
 *  org.apache.log4j.Logger
 *  org.springframework.beans.factory.annotation.Autowired
 *  org.springframework.stereotype.Repository
 *  org.springframework.transaction.annotation.Propagation
 *  org.springframework.transaction.annotation.Transactional
 */
package com.hst.taxService.dao.imp;

import com.hst.common.bo.FwhPubFile;
import com.hst.common.bo.FwhPubPic;
import com.hst.common.bo.FwhSwjgZhxxGr;
import com.hst.common.bo.FwhZzfdWxsmrz;
import com.hst.common.bo.LsbPtfpFpDkfpsq;
import com.hst.common.bo.LsbPtfpFpDkfpsqZb;
import com.hst.common.bo.LsbWebjkPublic;
import com.hst.common.bo.LsbWebjkPublic2;
import com.hst.common.bo.NsfwStpxPxkcBmmd;
import com.hst.common.bo.NsfwStpxPxkcPj;
import com.hst.common.bo.NsfwStpxPxkcYjjy;
import com.hst.common.bo.NsfwWsgpFplgsq;
import com.hst.common.bo.NsfwWsgpFpyjsq;
import com.hst.common.bo.NsfwWsgpSqzb;
import com.hst.common.bo.PtfpSpJkxx;
import com.hst.common.bo.PtfpSpJkxxMx;
import com.hst.common.bo.SmzBsyHtyzjl;
import com.hst.common.bo.SmzBsySfztx;
import com.hst.common.bo.SssxSlhz;
import com.hst.common.bo.SssxSlsqSqrYjxx;
import com.hst.common.bo.SssxSlsqSqrxx;
import com.hst.common.bo.SssxSlsqws;
import com.hst.common.bo.WsDjWjzkjsq;
import com.hst.common.bo.WsDjWjzkjsqZb;
import com.hst.common.bo.WsDjhz;
import com.hst.common.bo.WsFpDkfpsqLsb;
import com.hst.common.bo.WsFpDkfpsqLsbZb;
import com.hst.common.domain.NsrxxDomain;
import com.hst.common.domain.TaxCommonReturnDomain;
import com.hst.common.util.Base64;
import com.hst.common.util.DBConnectUtil;
import com.hst.common.util.EjbJ3Util;
import com.hst.common.util.HstWxServiceUtil;
import com.hst.common.util.OracleUtil;
import com.hst.common.util.ZlibCompress;
import com.hst.framework.common.HstSqlMapClientTemplate;
import com.hst.framework.constants.WebConstants;
import com.hst.framework.dao.BaseDao;
import com.hst.framework.exception.ServiceException;
import com.hst.framework.util.HstDateUtil;
import com.hst.framework.util.HstEncodeUtil;
import com.hst.framework.util.HstReflectUtil;
import com.hst.framework.util.HstToolsUtil;
import com.hst.taxService.domain.gt3.HxzgDjCxNsrSfzxxDomain;
import com.hst.taxService.domain.gt3.HxzgDjCxNsrSfzxxRequestDomain;
import com.hst.taxService.domain.gt3.HxzgDjCxNsrSfzxxResponseDomain;
import com.hst.taxService.domain.wxfwh.BsyDxSmyzAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkCheckSqzgAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkCheckSqzgReturnDomain;
import com.hst.taxService.domain.wxfwh.FpdkCheckZspmDomain;
import com.hst.taxService.domain.wxfwh.FpdkCxGhfxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkCxGhfxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpdkCxNsrSqslxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkCxNsrSqslxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpdkCxSqslMxxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkCxSqslMxxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpdkQueryDkfpSfzxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkQueryDkfpSfzxxDomain;
import com.hst.taxService.domain.wxfwh.FpdkQueryDkfpSfzxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpdkQueryQyGlxxBySfzhmAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkQueryQyGlxxBySfzhmReturnDomain;
import com.hst.taxService.domain.wxfwh.FpdkQxsqAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkQxsqReturnDomain;
import com.hst.taxService.domain.wxfwh.FpdkSaveSqxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpdkSaveSqxxDomain;
import com.hst.taxService.domain.wxfwh.FpdkSaveSqxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCheckSqzgAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCheckSqzgReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrDylgxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrDylgxxDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrDylgxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrFpyjxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrFpyjxxDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrFpyjxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrJcxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrJcxxDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrJcxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrPzxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrPzxxDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrPzxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrSqslxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrSqslxxDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxNsrSqslxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxSqslMxxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxCxSqslMxxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxQxsqAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxQxsqReturnDomain;
import com.hst.taxService.domain.wxfwh.FpjylxSaveSqxxAppDomain;
import com.hst.taxService.domain.wxfwh.FpjylxSaveSqxxReturnDomain;
import com.hst.taxService.domain.wxfwh.FpyjlxSaveLgsqDomain;
import com.hst.taxService.domain.wxfwh.FpyjlxSaveYjsqDomain;
import com.hst.taxService.domain.wxfwh.GkdhCxAppDomain;
import com.hst.taxService.domain.wxfwh.GkdhCxDomain;
import com.hst.taxService.domain.wxfwh.GkdhCxReturnDomain;
import com.hst.taxService.domain.wxfwh.GlyCxDhhmAppDomain;
import com.hst.taxService.domain.wxfwh.GlyCxTjAppDomain;
import com.hst.taxService.domain.wxfwh.GlyGetBssxAppDomain;
import com.hst.taxService.domain.wxfwh.MenuxxDomain;
import com.hst.taxService.domain.wxfwh.NsrDxyzmYzAppDomain;
import com.hst.taxService.domain.wxfwh.NsrDxyzmYzReturnDomain;
import com.hst.taxService.domain.wxfwh.PubBdNsrAppDomain;
import com.hst.taxService.domain.wxfwh.PubBdNsrDomain;
import com.hst.taxService.domain.wxfwh.PubBdNsrReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetBsdtAppDomain;
import com.hst.taxService.domain.wxfwh.PubGetBsdtDomain;
import com.hst.taxService.domain.wxfwh.PubGetBsdtReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetDmbxxAppDomain;
import com.hst.taxService.domain.wxfwh.PubGetDmbxxDomain;
import com.hst.taxService.domain.wxfwh.PubGetDmbxxReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetFileAppDomain;
import com.hst.taxService.domain.wxfwh.PubGetFileReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetFjxhAppDomain;
import com.hst.taxService.domain.wxfwh.PubGetFjxhReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetJdxzAppDomain;
import com.hst.taxService.domain.wxfwh.PubGetJdxzReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetNsrAppDomain;
import com.hst.taxService.domain.wxfwh.PubGetNsrDxyzmAppDomain;
import com.hst.taxService.domain.wxfwh.PubGetNsrDxyzmReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetNsrReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetPicAppDomain;
import com.hst.taxService.domain.wxfwh.PubGetPicReturnDomain;
import com.hst.taxService.domain.wxfwh.PubGetSmzDxyzmAppDomain;
import com.hst.taxService.domain.wxfwh.PubGrszxxAppDomain;
import com.hst.taxService.domain.wxfwh.PubGrszxxReturnDomain;
import com.hst.taxService.domain.wxfwh.PubMenuBsznAppDomain;
import com.hst.taxService.domain.wxfwh.PubMenuBsznDomain;
import com.hst.taxService.domain.wxfwh.PubMenuBsznReturnDomain;
import com.hst.taxService.domain.wxfwh.PubMenuXxslAppDomain;
import com.hst.taxService.domain.wxfwh.PubMenuXxslDomain;
import com.hst.taxService.domain.wxfwh.PubMenuXxslReturnDomain;
import com.hst.taxService.domain.wxfwh.PubPutFjAppDomain;
import com.hst.taxService.domain.wxfwh.PubPutUserMessAppDomain;
import com.hst.taxService.domain.wxfwh.PubPutUserMessReturnDomain;
import com.hst.taxService.domain.wxfwh.PubSaveSmrzxx2AppDomain;
import com.hst.taxService.domain.wxfwh.PubSaveSmrzxxAppDomain;
import com.hst.taxService.domain.wxfwh.PubSwjgMenuAppDomain;
import com.hst.taxService.domain.wxfwh.PubSwjgMenuReturnDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxDelAppDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxDelReturnDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxGetAppDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxGetDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxGetReturnDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxJhAppDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxJhCloseAppDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxJhCloseReturnDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxJhReturnDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxSaveAppDomain;
import com.hst.taxService.domain.wxfwh.QympGhfDjxxSaveReturnDomain;
import com.hst.taxService.domain.wxfwh.QympGhfKprGetAppDomain;
import com.hst.taxService.domain.wxfwh.QympGhfKprGetReturnDomain;
import com.hst.taxService.domain.wxfwh.QympGhfKprSaveAppDomain;
import com.hst.taxService.domain.wxfwh.QympGhfKprSaveReturnDomain;
import com.hst.taxService.domain.wxfwh.QympXhfKpxxTqAppDomain;
import com.hst.taxService.domain.wxfwh.QympXhfKpxxTqReturnDomain;
import com.hst.taxService.domain.wxfwh.QympXhfzcAppDomain;
import com.hst.taxService.domain.wxfwh.QympXhfzcReturnDomain;
import com.hst.taxService.domain.wxfwh.QytjCxrwAppDomain;
import com.hst.taxService.domain.wxfwh.QytjCxrwReturnDomain;
import com.hst.taxService.domain.wxfwh.QytjCxtjjgAppDomain;
import com.hst.taxService.domain.wxfwh.QytjCxtjjgReturnDomain;
import com.hst.taxService.domain.wxfwh.QytjDelrwAppDomain;
import com.hst.taxService.domain.wxfwh.QytjTjrwAppDomain;
import com.hst.taxService.domain.wxfwh.SqhdGetMessAppDomain;
import com.hst.taxService.domain.wxfwh.SqhdGetMessReturnDomain;
import com.hst.taxService.domain.wxfwh.SqhdSendMessAppDomain;
import com.hst.taxService.domain.wxfwh.SqhdSendMessReturnDomain;
import com.hst.taxService.domain.wxfwh.StpxCxKcxxAppDomain;
import com.hst.taxService.domain.wxfwh.StpxCxKcxxDomain;
import com.hst.taxService.domain.wxfwh.StpxCxKcxxReturnDomain;
import com.hst.taxService.domain.wxfwh.StpxCxKcxxxxAppDomain;
import com.hst.taxService.domain.wxfwh.StpxCxKcxxxxDomain;
import com.hst.taxService.domain.wxfwh.StpxCxKcxxxxReturnDomain;
import com.hst.taxService.domain.wxfwh.StpxCxPjnrAppDomain;
import com.hst.taxService.domain.wxfwh.StpxCxPjnrDomain;
import com.hst.taxService.domain.wxfwh.StpxCxPjnrReturnDomain;
import com.hst.taxService.domain.wxfwh.StpxCxYbmkcAppDomain;
import com.hst.taxService.domain.wxfwh.StpxCxYbmkcDomain;
import com.hst.taxService.domain.wxfwh.StpxCxYbmkcReturnDomain;
import com.hst.taxService.domain.wxfwh.StpxSaveBmxxAppDomain;
import com.hst.taxService.domain.wxfwh.StpxSaveBmxxReturnDomain;
import com.hst.taxService.domain.wxfwh.StpxSavePjnrAppDomain;
import com.hst.taxService.domain.wxfwh.StpxSavePjnrDomain;
import com.hst.taxService.domain.wxfwh.StpxSavePjnrReturnDomain;
import com.hst.taxService.domain.wxfwh.StpxSaveYjyjAppDomain;
import com.hst.taxService.domain.wxfwh.StpxSaveYjyjReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrBdAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrBsyAddAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrBsyAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrBsyDelAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrBsyDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrBsyReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrJcAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrYzmAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxBdNsrYzmReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwBdxmAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwBdxmDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwBdxmReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwBdxmXzxAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwBdxmXzxDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwBdxmXzxReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwCjxxDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwListAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwListReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwNrAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwNrDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwNrReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwSaveAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxDbrwSaveFjAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxGetQhhmAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxGetQhhmReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxGlqymdAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxGlqymdReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxGrszGetPicAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxGrszGetPicDomain;
import com.hst.taxService.domain.wxfwh.WdsxGrszGetPicReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxGrszPutPicAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxGrszUpdateAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxKddListAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxKddListDomain;
import com.hst.taxService.domain.wxfwh.WdsxKddListReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxKddNrAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxKddNrDomain;
import com.hst.taxService.domain.wxfwh.WdsxKddNrReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxLzjdListAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxLzjdListDomain;
import com.hst.taxService.domain.wxfwh.WdsxLzjdListReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxLzjdNrAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxLzjdNrDomain;
import com.hst.taxService.domain.wxfwh.WdsxLzjdNrReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxLzjdSaveAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxLzjdWtxxDomain;
import com.hst.taxService.domain.wxfwh.WdsxNsrdjxxCxAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxNsrdjxxCxReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcCjxxDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcListAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcListDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcListReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcNrAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcNrDaxxAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcNrDaxxDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcNrDaxxReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcNrDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcNrReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcSaveAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxPjdcSaveReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxQhhmPjAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxSaveHfxxAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxSstxDomain;
import com.hst.taxService.domain.wxfwh.WdsxSstxListAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxSstxListReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxSstxNrAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxSstxNrReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxTzggDomain;
import com.hst.taxService.domain.wxfwh.WdsxTzggFjDomain;
import com.hst.taxService.domain.wxfwh.WdsxTzggListAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxTzggListReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxTzggNrAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxTzggNrReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxYjjyListAppDomain;
import com.hst.taxService.domain.wxfwh.WdsxYjjyListDomain;
import com.hst.taxService.domain.wxfwh.WdsxYjjyListReturnDomain;
import com.hst.taxService.domain.wxfwh.WdsxYjjySaveAppDomain;
import com.hst.taxService.domain.wxfwh.WghGrxxCxAppDomain;
import com.hst.taxService.domain.wxfwh.WghGrxxCxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghGrxxSaveAppDomain;
import com.hst.taxService.domain.wxfwh.WghGrxxSaveReturnDomain;
import com.hst.taxService.domain.wxfwh.WghJkxxSaveAppDomain;
import com.hst.taxService.domain.wxfwh.WghJkxxSaveDomain;
import com.hst.taxService.domain.wxfwh.WghJkxxSaveReturnDomain;
import com.hst.taxService.domain.wxfwh.WghJkxxSaveSubDomain;
import com.hst.taxService.domain.wxfwh.WghJkxxZfAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBd2AppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdAddbsyAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdCxbsyAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdCxbsyReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdDelbsyAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdGetmdAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdGetmdReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdJc2AppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdJcAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdJcReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdYzm2AppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdYzm2ReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdYzmAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdYzmReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdxxCx2AppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdxxCx2ReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdxxCxAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrBdxxCxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrDsqccxAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrDsqccxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrJcxxcjCxAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrJcxxcjCxDomain;
import com.hst.taxService.domain.wxfwh.WghNsrJcxxcjCxNsrtxDomain;
import com.hst.taxService.domain.wxfwh.WghNsrJcxxcjCxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrJcxxcjCxXxDomain;
import com.hst.taxService.domain.wxfwh.WghNsrJcxxcjSaveAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrJcxxcjSaveDomain;
import com.hst.taxService.domain.wxfwh.WghNsrKpmxcxAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrKpmxcxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrKpxxcxAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrKpxxcxDomain;
import com.hst.taxService.domain.wxfwh.WghNsrSfxycxAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrSfxycxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghNsrSfzcxAppDomain;
import com.hst.taxService.domain.wxfwh.WghNsrSfzcxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghSqdCxAppDomain;
import com.hst.taxService.domain.wxfwh.WghSqdCxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghSqdListCxAppDomain;
import com.hst.taxService.domain.wxfwh.WghSqdListCxReturnDomain;
import com.hst.taxService.domain.wxfwh.WghSqdSaveAppDomain;
import com.hst.taxService.domain.wxfwh.WghSqdSaveReturnDomain;
import com.hst.taxService.domain.wxfwh.WghSqdZfAppDomain;
import com.hst.taxService.domain.wxfwh.WghSqdZfReturnDomain;
import com.hst.taxService.domain.wxfwh.WjzCheckSqzgAppDomain;
import com.hst.taxService.domain.wxfwh.WjzCheckSqzgReturnDomain;
import com.hst.taxService.domain.wxfwh.WjzCxYsqxxAppDomain;
import com.hst.taxService.domain.wxfwh.WjzCxYsqxxDomain;
import com.hst.taxService.domain.wxfwh.WjzCxYsqxxReturnDomain;
import com.hst.taxService.domain.wxfwh.WjzQxsqAppDomain;
import com.hst.taxService.domain.wxfwh.WjzQxsqReturnDomain;
import com.hst.taxService.domain.wxfwh.WjzSaveSqxxAppDomain;
import com.hst.taxService.domain.wxfwh.WjzSaveSqxxDomain;
import com.hst.taxService.domain.wxfwh.WjzSaveSqxxReturnDomain;
import com.hst.taxService.domain.wxfwh.WycxNsrwsjdcxAppDomain;
import com.hst.taxService.domain.wxfwh.WycxNsrwsjdcxDomain;
import com.hst.taxService.domain.wxfwh.WycxNsrwsjdcxReturnDomain;
import com.hst.taxService.domain.wxfwh.XxcjDelSczlAppDomain;
import com.hst.taxService.domain.wxfwh.XxcjDelSczlReturnDomain;
import com.hst.taxService.domain.wxfwh.XxcjGetNsrZlscqkAppDomain;
import com.hst.taxService.domain.wxfwh.XxcjGetNsrZlscqkReturnDomain;
import com.hst.taxService.domain.wxfwh.XxcjGetNsrZlyscxxAppDomain;
import com.hst.taxService.domain.wxfwh.XxcjGetNsrZlyscxxReturnDomain;
import com.hst.taxService.domain.wxfwh.XxcjGetNsrmdAppDomain;
import com.hst.taxService.domain.wxfwh.XxcjGetNsrmdReturnDomain;
import com.hst.taxService.domain.wxfwh.XxcjSaveSczlAppDomain;
import com.hst.taxService.domain.wxfwh.XxcjSaveSczlReturnDomain;
import com.hst.taxService.domain.wxfwh.XxcjSczlTjshAppDomain;
import com.hst.taxService.domain.wxfwh.YyfwBsypjAppDomain;
import com.hst.taxService.domain.wxfwh.YyfwBsypjReturnDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxWyyyxxAppDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxWyyyxxDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxWyyyxxReturnDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxZjxxAppDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxZjxxDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxZjxxReturnDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxZjyyfbsjAppDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxZjyyfbsjDomain;
import com.hst.taxService.domain.wxfwh.YyfwCxZjyyfbsjReturnDomain;
import com.hst.taxService.domain.wxfwh.YyfwQxyyfwAppDomain;
import com.hst.taxService.domain.wxfwh.YyfwQxyyfwReturnDomain;
import com.hst.taxService.domain.wxfwh.YyfwSaveYyxxAppDomain;
import com.hst.taxService.domain.wxfwh.YyfwSaveYyxxReturnDomain;
import com.hst.taxService.domain.wxfwh.ZgswgyCxAppDomain;
import com.hst.taxService.domain.wxfwh.ZgswgyCxReturnDomain;
import com.hst.taxService.domain.wxfwh.ZgswjgCxAppDomain;
import com.hst.taxService.domain.wxfwh.ZgswjgCxReturnDomain;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Repository
public class TaxWxfwhAppDaoImp
implements BaseDao {
    @Autowired
    private HstSqlMapClientTemplate sqlMapClientTemplate;
    @Autowired
    private HstSqlMapClientTemplate ssglSqlMapClientTemplate;
    @Autowired
    private HstSqlMapClientTemplate xshsSqlMapClientTemplate;
    private static Logger _log = Logger.getLogger(TaxWxfwhAppDaoImp.class);

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain pubSwjgMenu(PubSwjgMenuAppDomain domain) throws Exception {
        PubSwjgMenuReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("jyYzm", domain.getJyYzm());
        map.put("lb", domain.getLb());
        map.put("code", "");
        map.put("mess", "");
        map.put("pubSwjgMenuList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("pubSwjgMenuCurr", "pubSwjgMenuList", map);
        ArrayList<MenuxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("pubSwjgMenuList");
        returnDomain = new PubSwjgMenuReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain pubBdNsrxx(PubBdNsrAppDomain domain) throws Exception {
        PubBdNsrReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("code", "");
        map.put("mess", "");
        map.put("hshj", "");
        map.put("pubBdNsrxxList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("pubBdNsrxxCurr", "pubBdNsrxxList", map);
        ArrayList<PubBdNsrDomain> dataList = new ArrayList();
        dataList = (List)map.get("pubBdNsrxxList");
        returnDomain = new PubBdNsrReturnDomain();
        returnDomain.setHshj((String)map.get("hshj"));
        returnDomain.setSfscyhxx((String)map.get("sfscyhxx"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain pubMenuXxsl(PubMenuXxslAppDomain domain) throws Exception {
        PubMenuXxslReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("code", "");
        map.put("mess", "");
        map.put("pubMenuXxslList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("pubMenuXxslCurr", "pubMenuXxslList", map);
        ArrayList<PubMenuXxslDomain> dataList = new ArrayList();
        dataList = (List)map.get("pubMenuXxslList");
        returnDomain = new PubMenuXxslReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain pubMenuBszn(PubMenuBsznAppDomain domain) throws Exception {
        PubMenuBsznReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("menuDm", domain.getMenuDm());
        map.put("code", "");
        map.put("mess", "");
        map.put("pubMenuBsznList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("pubMenuBsznCurr", "pubMenuBsznList", map);
        ArrayList<PubMenuBsznDomain> dataList = new ArrayList();
        dataList = (List)map.get("pubMenuBsznList");
        returnDomain = new PubMenuBsznReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain pubGetPic(PubGetPicAppDomain domain) throws Exception {
        PubGetPicReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("picDjxh", domain.getPicDjxh());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        map.put("databaseUsername", databaseUsername);
        FwhPubPic bo = (FwhPubPic)this.sqlMapClientTemplate.queryForObject("pubGetPicByKey", map);
        returnDomain = new PubGetPicReturnDomain();
        returnDomain.setCode("00");
        if (bo != null) {
            returnDomain.setPic(Base64.byteToString(bo.getPic()));
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain pubGetFile(PubGetFileAppDomain domain) throws Exception {
        PubGetFileReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("fileDjxh", domain.getFileDjxh());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        map.put("databaseUsername", databaseUsername);
        FwhPubFile file = (FwhPubFile)this.sqlMapClientTemplate.queryForObject("selectFwhPubFileByKey", map);
        returnDomain = new PubGetFileReturnDomain();
        if (file != null) {
            returnDomain.setCode("00");
            byte[] filedara = ZlibCompress.CompressionByte(file.getFiledata());
            returnDomain.setNr(Base64.byteToString(filedara).replaceAll("\r\n", "").replaceAll("\\s", "\\+"));
        } else {
            returnDomain.setCode("01");
            returnDomain.setMess("\u65e0\u6cd5\u627e\u5230\u76f8\u5173\u9644\u4ef6\u5185\u5bb9");
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain pubGetFjxh(PubGetFjxhAppDomain domain) throws Exception {
        PubGetFjxhReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        map.put("databaseUsername", databaseUsername);
        String fjDjxh = (String)this.sqlMapClientTemplate.queryForObject("pubGetFjxh", map);
        returnDomain = new PubGetFjxhReturnDomain();
        returnDomain.setCode("00");
        returnDomain.setFjDjxh(fjDjxh);
        return returnDomain;
    }

    public TaxCommonReturnDomain pubPutFj(PubPutFjAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("fileDjxh", domain.getFjDjxh());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        map.put("databaseUsername", databaseUsername);
        FwhPubFile dom = (FwhPubFile)this.sqlMapClientTemplate.queryForObject("selectFwhPubFileByKey", map);
        returnDomain = new TaxCommonReturnDomain();
        if (dom != null) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u9644\u4ef6\u767b\u8bb0\u5e8f\u53f7\u5df2\u7ecf\u5b58\u5728");
            return returnDomain;
        }
        if (StringUtils.isBlank((String)domain.getNr())) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u5185\u5bb9\u5fc5\u987b\u4f20\u5165");
            return returnDomain;
        }
        FwhPubFile bo = new FwhPubFile();
        bo.setDatabaseUsername(databaseUsername);
        byte[] filedara = ZlibCompress.DecompressionByte(Base64.stringToByte(domain.getNr()));
        bo.setFiledata(filedara);
        bo.setFileDjxh(domain.getFjDjxh());
        this.sqlMapClientTemplate.insert("insertFwhPubFile", bo);
        returnDomain.setCode("00");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain pubGrszxx(PubGrszxxAppDomain domain) throws Exception {
        PubGrszxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("code", "");
        map.put("mess", "");
        map.put("pubGrszxxList", "");
        this.sqlMapClientTemplate.queryForObjectByCurr("pubGrszxxCurr", "pubGrszxxList", map);
        List dataList = new ArrayList();
        dataList = (List)map.get("pubGrszxxList");
        returnDomain = dataList.isEmpty() ? new PubGrszxxReturnDomain() : (PubGrszxxReturnDomain)dataList.get(0);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxTzggList(WdsxTzggListAppDomain domain) throws Exception {
        WdsxTzggListReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getStr())) {
            map.put("str", "");
        } else {
            map.put("str", HstEncodeUtil.GBK2ISO(domain.getStr()));
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxTzggList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxTzggListCurr", "wdsxTzggList", map);
        ArrayList<WdsxTzggDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxTzggList");
        returnDomain = new WdsxTzggListReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxTzggNr(WdsxTzggNrAppDomain domain) throws Exception {
        WdsxTzggNrReturnDomain returnDomain = new WdsxTzggNrReturnDomain();
        Connection conn = null;
        Statement cstmt = null;
        ResultSet rs = null;
        try {
            try {
                conn = this.sqlMapClientTemplate.getDataSource().getConnection();
            }
            catch (Exception e) {
                returnDomain.setCode("01");
                returnDomain.setMess(e.toString());
                _log.error((Object)e.toString());
                WdsxTzggNrReturnDomain wdsxTzggNrReturnDomain = returnDomain;
                if (rs != null) {
                    rs.close();
                }
                if (cstmt != null) {
                    cstmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
                return wdsxTzggNrReturnDomain;
            }
            try {
                conn.setAutoCommit(false);
                String proc = "{call P_WEBJK_WXFW622_WDSXTZGGNR(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}";
                cstmt = conn.prepareCall(proc);
                int parIndex = 1;
                cstmt.setString(parIndex++, domain.getSwjgDm());
                cstmt.setString(parIndex++, domain.getOpenId());
                cstmt.setString(parIndex++, domain.getTzggXh());
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 2005);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, -10);
                String parStrs = "[" + domain.getSwjgDm() + "," + domain.getOpenId() + "," + domain.getTzggXh() + "]";
                _log.info((Object)("\u6267\u884c\u5b58\u50a8\u8fc7\u7a0b\uff1a" + proc + ";\u53c2\u6570:" + parStrs));
                cstmt.execute();
                rs = (ResultSet)cstmt.getObject(17);
                ArrayList<WdsxTzggFjDomain> dataList = new ArrayList<WdsxTzggFjDomain>();
                while (rs.next()) {
                    WdsxTzggFjDomain fjDom = new WdsxTzggFjDomain();
                    String fjDjxh = rs.getString("FJ_DJ_XH");
                    String fjMc = rs.getString("FJ_MC");
                    fjDom.setFjDjxh(fjDjxh);
                    fjDom.setFjMc(HstToolsUtil.ISO2GBK(fjMc));
                    dataList.add(fjDom);
                }
                String bt = cstmt.getString(4);
                String ly = cstmt.getString(5);
                String rq = cstmt.getString(6);
                String nr = cstmt.getString(7);
                String sfdt = cstmt.getString(8);
                String picDjxh = cstmt.getString(9);
                String picTgzxm = cstmt.getString(10);
                String nsrmc = cstmt.getString(11);
                String nsrmcAll = cstmt.getString(12);
                String hfxx = cstmt.getString(13);
                cstmt.getString(14);
                String code = cstmt.getString(15);
                String mess = cstmt.getString(16);
                returnDomain.setLy(domain.getTzggXh());
                returnDomain.setBt(HstToolsUtil.ISO2GBK(bt));
                returnDomain.setLy(HstToolsUtil.ISO2GBK(ly));
                returnDomain.setRq(rq);
                returnDomain.setNr(HstToolsUtil.ISO2GBK(nr));
                returnDomain.setSfdt(sfdt);
                returnDomain.setPicDjxh(picDjxh);
                returnDomain.setPicTgzxm(picTgzxm);
                returnDomain.setNsrmc(HstToolsUtil.ISO2GBK(nsrmc));
                returnDomain.setNsrmcAll(HstToolsUtil.ISO2GBK(nsrmcAll));
                returnDomain.setCode(code);
                returnDomain.setMess(HstToolsUtil.ISO2GBK(mess));
                returnDomain.setDataList(dataList);
                returnDomain.setHfxx(HstToolsUtil.ISO2GBK(hfxx));
                conn.commit();
            }
            catch (Exception e) {
                conn.rollback();
                returnDomain = new WdsxTzggNrReturnDomain();
                returnDomain.setCode("01");
                returnDomain.setMess(e.toString());
                _log.error((Object)e.toString());
                WdsxTzggNrReturnDomain wdsxTzggNrReturnDomain = returnDomain;
                return wdsxTzggNrReturnDomain;
            }
        }
        finally {
            if (rs != null) {
                rs.close();
            }
            if (cstmt != null) {
                cstmt.close();
            }
            if (conn != null) {
                conn.close();
            }
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxSstxList(WdsxSstxListAppDomain domain) throws Exception {
        WdsxSstxListReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getStr())) {
            map.put("str", "");
        } else {
            map.put("str", HstEncodeUtil.GBK2ISO(domain.getStr()));
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxSstxList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxSstxListCurr", "wdsxSstxList", map);
        ArrayList<WdsxSstxDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxSstxList");
        returnDomain = new WdsxSstxListReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxSstxNr(WdsxSstxNrAppDomain domain) throws Exception {
        WdsxSstxNrReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("sstxXh", domain.getSstxXh());
        map.put("ly", "");
        map.put("rq", "");
        map.put("nr", "");
        map.put("nsrmc", "");
        map.put("nsrmcAll", "");
        map.put("ckbz", "");
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxSstxNrCurr", map, new String[0]);
        returnDomain = new WdsxSstxNrReturnDomain();
        returnDomain.setSstxXh(domain.getSstxXh());
        returnDomain.setLy(HstToolsUtil.ISO2GBK((String)map.get("ly")));
        returnDomain.setRq((String)map.get("rq"));
        returnDomain.setNr(HstToolsUtil.ISO2GBK((String)map.get("nr")));
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setNsrmcAll(HstToolsUtil.ISO2GBK((String)map.get("nsrmcAll")));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxDbrwList(WdsxDbrwListAppDomain domain) throws Exception {
        WdsxDbrwListReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getStr())) {
            map.put("str", "");
        } else {
            map.put("str", HstEncodeUtil.GBK2ISO(domain.getStr()));
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxDbrwList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxDbrwListtCurr", "wdsxDbrwList", map);
        ArrayList<WdsxDbrwDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxDbrwList");
        returnDomain = new WdsxDbrwListReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxDbrwNr(WdsxDbrwNrAppDomain domain) throws Exception {
        WdsxDbrwNrReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("dbrwXh", domain.getDbrwXh());
        map.put("djxh", domain.getDjxh());
        map.put("nsrmc", "");
        map.put("bt", "");
        map.put("ly", "");
        map.put("rq", "");
        map.put("bjqx", "");
        map.put("wcbz", "");
        map.put("bdlx", "");
        map.put("rwsm", "");
        map.put("wcrq", "");
        map.put("wcsm", "");
        map.put("wcrxm", "");
        map.put("xffj", "");
        map.put("scfj", "");
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxDbrwNrList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxDbrwNrCurr", "wdsxDbrwNrList", map);
        ArrayList<WdsxDbrwNrDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxDbrwNrList");
        returnDomain = new WdsxDbrwNrReturnDomain();
        returnDomain.setDbrwXh((String)map.get("dbrwXh"));
        returnDomain.setNsrsbh((String)map.get("nsrsbh"));
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setBt(HstToolsUtil.ISO2GBK((String)map.get("bt")));
        returnDomain.setLy(HstToolsUtil.ISO2GBK((String)map.get("ly")));
        returnDomain.setRq((String)map.get("rq"));
        returnDomain.setBjqx((String)map.get("bjqx"));
        returnDomain.setWcbz((String)map.get("wcbz"));
        returnDomain.setBdlx((String)map.get("bdlx"));
        returnDomain.setRwsm(HstToolsUtil.ISO2GBK((String)map.get("rwsm")));
        returnDomain.setWcrq((String)map.get("wcrq"));
        returnDomain.setWcsm(HstToolsUtil.ISO2GBK((String)map.get("wcsm")));
        returnDomain.setWcrxm(HstToolsUtil.ISO2GBK((String)map.get("wcrxm")));
        returnDomain.setXffj((String)map.get("xffj"));
        returnDomain.setScfj((String)map.get("scfj"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxDbrwBdxm(WdsxDbrwBdxmAppDomain domain) throws Exception {
        WdsxDbrwBdxmReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("dbrwXh", domain.getDbrwXh());
        map.put("djxh", domain.getDjxh());
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxDbrwBdxmList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxDbrwBdxmCurr", "wdsxDbrwBdxmList", map);
        ArrayList<WdsxDbrwBdxmDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxDbrwBdxmList");
        returnDomain = new WdsxDbrwBdxmReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxDdrwBdxmXzx(WdsxDbrwBdxmXzxAppDomain domain) throws Exception {
        WdsxDbrwBdxmXzxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("dbrwXh", domain.getDbrwXh());
        map.put("djxh", domain.getDjxh());
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxDdrwBdxmXzxList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxDdrwBdxmXzxCurr", "wdsxDdrwBdxmXzxList", map);
        ArrayList<WdsxDbrwBdxmXzxDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxDdrwBdxmXzxList");
        returnDomain = new WdsxDbrwBdxmXzxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxDbrwSave(WdsxDbrwSaveAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        if (domain.getDataList().isEmpty()) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u8bf7\u68c0\u67e5\uff0c\u6570\u636e\u4e3a\u7a7a");
            return returnDomain;
        }
        String pclXh = "";
        LsbWebjkPublic lsb = null;
        for (WdsxDbrwCjxxDomain dom : domain.getDataList()) {
            lsb = new LsbWebjkPublic();
            if (HstToolsUtil.isNullOrEmpty(pclXh)) {
                lsb.setYwxhXh(dom.getHxmxh());
                lsb.setXh(dom.getLxmxh());
                lsb.setNr(dom.getSjxz());
                this.sqlMapClientTemplate.insert("saveLsbWebjkPublic", lsb);
                pclXh = lsb.getPclXh();
            } else {
                lsb.setPclXh(pclXh);
                lsb.setYwxhXh(dom.getHxmxh());
                lsb.setXh(dom.getLxmxh());
                lsb.setNr(dom.getSjxz());
                this.sqlMapClientTemplate.insert("saveLsbWebjkPublicByPclXh", lsb);
            }
            lsb = null;
        }
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("dbrwXh", domain.getDbrwXh());
        map.put("djxh", domain.getDjxh());
        map.put("wcbz", domain.getWcbz());
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("wcsm", HstEncodeUtil.UTF82ISO(domain.getWcsm()));
        }
        if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("wcsm", HstEncodeUtil.UTF82GBK(domain.getWcsm()));
        }
        map.put("pclXh", pclXh);
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObject("wdsxDbrwSave", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxDbrwSaveFj(WdsxDbrwSaveFjAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("dbrwXh", domain.getDbrwXh());
        map.put("djxh", domain.getDjxh());
        map.put("fjxh", domain.getFjxh());
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("fjmc", HstEncodeUtil.UTF82ISO(domain.getFjmc()));
        }
        if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("fjmc", HstEncodeUtil.UTF82GBK(domain.getFjmc()));
        }
        map.put("yxbz", domain.getYxbz());
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObject("wdsxDbrwSaveFjCurr", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxKddList(WdsxKddListAppDomain domain) throws Exception {
        WdsxKddListReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getStr())) {
            map.put("str", "");
        } else {
            map.put("str", HstEncodeUtil.GBK2ISO(domain.getStr()));
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxKddList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxKddListCurr", "wdsxKddList", map);
        ArrayList<WdsxKddListDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxKddList");
        returnDomain = new WdsxKddListReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxKddNr(WdsxKddNrAppDomain domain) throws Exception {
        WdsxKddNrReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("kddh", domain.getKddh());
        map.put("kdgsmc", "");
        map.put("jjrmc", "");
        map.put("jjrq", "");
        map.put("wlzt", "");
        map.put("bz", "");
        map.put("nsrsbh", "");
        map.put("nsrmc", "");
        map.put("dz", "");
        map.put("yb", "");
        map.put("sjr", "");
        map.put("sjhm", "");
        map.put("gddh", "");
        map.put("pcrq", "");
        map.put("qsrq", "");
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxKddNrList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxKddNrCurr", "wdsxKddNrList", map);
        ArrayList<WdsxKddNrDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxKddNrList");
        returnDomain = new WdsxKddNrReturnDomain();
        returnDomain.setKddh((String)map.get("kddh"));
        returnDomain.setKdgsmc(HstToolsUtil.ISO2GBK((String)map.get("kdgsmc")));
        returnDomain.setJjrmc(HstToolsUtil.ISO2GBK((String)map.get("jjrmc")));
        returnDomain.setJjrq((String)map.get("jjrq"));
        returnDomain.setWlzt((String)map.get("wlzt"));
        returnDomain.setBz((String)map.get("bz"));
        returnDomain.setNsrsbh((String)map.get("nsrsbh"));
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setDz(HstToolsUtil.ISO2GBK((String)map.get("dz")));
        returnDomain.setYb((String)map.get("yb"));
        returnDomain.setSjr(HstToolsUtil.ISO2GBK((String)map.get("sjr")));
        returnDomain.setSjhm((String)map.get("sjhm"));
        returnDomain.setGddh((String)map.get("gddh"));
        returnDomain.setPcrq((String)map.get("pcrq"));
        returnDomain.setQsrq((String)map.get("qsrq"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxPjdcList(WdsxPjdcListAppDomain domain) throws Exception {
        WdsxPjdcListReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getStr())) {
            map.put("str", "");
        } else {
            map.put("str", HstEncodeUtil.GBK2ISO(domain.getStr()));
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxPjdcList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxPjdcListCurr", "wdsxPjdcList", map);
        ArrayList<WdsxPjdcListDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxPjdcList");
        returnDomain = new WdsxPjdcListReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxPjdcNr(WdsxPjdcNrAppDomain domain) throws Exception {
        WdsxPjdcNrReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjg_Dm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("wjdcfqXh", domain.getWjdcfqXh());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("dcbMc", "");
        map.put("zt", "");
        map.put("swjgDm", "");
        map.put("swjgMc", "");
        map.put("fqrq", "");
        map.put("nsrmc", "");
        map.put("fqy", "");
        map.put("wjdccjXh", "");
        map.put("txrq", "");
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxPjdcNrList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxPjdcNrCurr", "wdsxPjdcNrList", map);
        ArrayList<WdsxPjdcNrDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxPjdcNrList");
        returnDomain = new WdsxPjdcNrReturnDomain();
        returnDomain.setWjdcfqXh((String)map.get("wjdcfqXh"));
        returnDomain.setDcbMc(HstToolsUtil.ISO2GBK((String)map.get("dcbMc")));
        returnDomain.setZt((String)map.get("zt"));
        returnDomain.setSwjgDm((String)map.get("swjgDm"));
        returnDomain.setSwjgMc(HstToolsUtil.ISO2GBK((String)map.get("swjgMc")));
        returnDomain.setFqrq((String)map.get("fqrq"));
        returnDomain.setNsrsbh((String)map.get("nsrsbh"));
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setFqy(HstToolsUtil.ISO2GBK((String)map.get("fqy")));
        returnDomain.setWjdccjXh((String)map.get("wjdccjXh"));
        returnDomain.setTxrq((String)map.get("txrq"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxPjdcNrDaxx(WdsxPjdcNrDaxxAppDomain domain) throws Exception {
        WdsxPjdcNrDaxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("wjdcfqXh", domain.getWjdcfqXh());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxPjdcNrDaxxList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxPjdcNrDaxxCurr", "wdsxPjdcNrDaxxList", map);
        ArrayList<WdsxPjdcNrDaxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxPjdcNrDaxxList");
        returnDomain = new WdsxPjdcNrDaxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxPjdcSave(WdsxPjdcSaveAppDomain domain) throws Exception {
        WdsxPjdcSaveReturnDomain returnDomain = new WdsxPjdcSaveReturnDomain();
        if (domain.getDataList().isEmpty()) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u8bf7\u68c0\u67e5\uff0c\u6570\u636e\u4e3a\u7a7a");
            return returnDomain;
        }
        String pclXh = "";
        LsbWebjkPublic lsb = null;
        String[] str = null;
        for (WdsxPjdcCjxxDomain dom : domain.getDataList()) {
            lsb = new LsbWebjkPublic();
            lsb.setYwxhXh(dom.getWtxh());
            if (HstToolsUtil.isNullOrEmpty(dom.getWtda()) || "9999".equals(dom.getWtda())) {
                lsb.setXh("9999");
                lsb.setNr(dom.getYjjy());
            } else {
                String[] stringArray = str = dom.getWtda().split("\\|");
                int n = str.length;
                int n2 = 0;
                while (n2 < n) {
                    String wtnr = stringArray[n2];
                    String[] wtdas = wtnr.split(":");
                    if (wtdas.length > 1) {
                        lsb.setNr(wtdas[1]);
                    }
                    lsb.setXh(wtdas[0]);
                    if (HstToolsUtil.isNullOrEmpty(pclXh)) {
                        this.sqlMapClientTemplate.insert("saveLsbWebjkPublic", lsb);
                        pclXh = lsb.getPclXh();
                    } else {
                        lsb.setPclXh(pclXh);
                        this.sqlMapClientTemplate.insert("saveLsbWebjkPublicByPclXh", lsb);
                    }
                    ++n2;
                }
            }
            str = null;
            lsb = null;
        }
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("wjdcfqXh", domain.getWjdcfqXh());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("pclXh", pclXh);
        map.put("wjdccjXh", "");
        map.put("txrq", "");
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObject("wdsxPjdcSaveCurr", map);
        returnDomain.setWjdccjXh((String)map.get("wjdccjXh"));
        returnDomain.setTxrq((String)map.get("txrq"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxLzjdList(WdsxLzjdListAppDomain domain) throws Exception {
        WdsxLzjdListReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getStr())) {
            map.put("str", "");
        } else {
            map.put("str", HstEncodeUtil.GBK2ISO(domain.getStr()));
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxLzjdList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxLzjdListCurr", "wdsxLzjdList", map);
        ArrayList<WdsxLzjdListDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxLzjdList");
        returnDomain = new WdsxLzjdListReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxLzjdNr(WdsxLzjdNrAppDomain domain) throws Exception {
        WdsxLzjdNrReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjg_Dm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("lzjdDjxh", domain.getLzjdDjxh());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("swjgDm", "");
        map.put("swjgMc", "");
        map.put("nsrmc", "");
        map.put("lxdh", "");
        map.put("zffwsy", "");
        map.put("pcbm", "");
        map.put("gzry", "");
        map.put("txrq", "");
        map.put("bh", "");
        map.put("zt", "");
        map.put("tjsj", "");
        map.put("tjr", "");
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxLzjdNrList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxLzjdNrCurr", "wdsxLzjdNrList", map);
        ArrayList<WdsxLzjdNrDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxLzjdNrList");
        returnDomain = new WdsxLzjdNrReturnDomain();
        returnDomain.setLzjdDjxh((String)map.get("lzjdDjxh"));
        returnDomain.setSwjgDm((String)map.get("swjgDm"));
        returnDomain.setSwjgMc(HstToolsUtil.ISO2GBK((String)map.get("swjgMc")));
        returnDomain.setNsrsbh((String)map.get("nsrsbh"));
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setLxdh((String)map.get("lxdh"));
        returnDomain.setZffwsy(HstToolsUtil.ISO2GBK((String)map.get("zffwsy")));
        returnDomain.setPcbm(HstToolsUtil.ISO2GBK((String)map.get("pcbm")));
        returnDomain.setGzry(HstToolsUtil.ISO2GBK((String)map.get("gzry")));
        returnDomain.setTxrq((String)map.get("txrq"));
        returnDomain.setBh((String)map.get("bh"));
        returnDomain.setZt((String)map.get("zt"));
        returnDomain.setXfsj((String)map.get("xfsj"));
        returnDomain.setTjsj((String)map.get("tjsj"));
        returnDomain.setTjr((String)map.get("tjr"));
        returnDomain.setTxrq((String)map.get("txrq"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxLzjdSave(WdsxLzjdSaveAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        if (domain.getDataList().isEmpty()) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u8bf7\u68c0\u67e5\uff0c\u6570\u636e\u4e3a\u7a7a");
            return returnDomain;
        }
        String pclXh = "";
        LsbWebjkPublic2 lsb = null;
        for (WdsxLzjdWtxxDomain dom : domain.getDataList()) {
            lsb = new LsbWebjkPublic2();
            if (HstToolsUtil.isNullOrEmpty(pclXh)) {
                lsb.setYwxhXh(dom.getWtbm());
                lsb.setCol_1(dom.getWtms());
                lsb.setCol_2(dom.getWtda());
                this.sqlMapClientTemplate.insert("saveLsbWebjkPublic2", lsb);
                pclXh = lsb.getPclXh();
                continue;
            }
            lsb.setPclXh(pclXh);
            lsb.setYwxhXh(dom.getWtbm());
            lsb.setCol_1(dom.getWtms());
            lsb.setCol_2(dom.getWtda());
            this.sqlMapClientTemplate.insert("saveLsbWebjkPublic2ByPclXh", lsb);
        }
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("lzjdDjxh", domain.getLzjdDjxh());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("pclXh", pclXh);
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObject("wdsxLzjdSaveCurr", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxBdNsrJc(WdsxBdNsrJcAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxBdNsrJcCurr", "", map);
        returnDomain = new TaxCommonReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxBdNsrYzm(WdsxBdNsrYzmAppDomain domain) throws Exception {
        WdsxBdNsrYzmReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("sfzhm", domain.getSfzhm());
        map.put("sjhm", domain.getSjhm());
        map.put("nsrmc", "");
        map.put("sflb", "");
        map.put("sfcwfzr", "");
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxBdNsrYzmList", null);
        this.sqlMapClientTemplate.queryForObject("wdsxBdNsrYzmCurr", map);
        returnDomain = new WdsxBdNsrYzmReturnDomain();
        returnDomain.setNsrsbh((String)map.get("nsrsbh"));
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setSfzhm((String)map.get("sfzhm"));
        returnDomain.setSjhm((String)map.get("sjhm"));
        returnDomain.setSflb(HstToolsUtil.ISO2GBK((String)map.get("sflb")));
        returnDomain.setSfCwfzr((String)map.get("sfcwfzr"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxBdNsrBd(WdsxBdNsrBdAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("sfzhm", domain.getSfzhm());
        map.put("sjhm", domain.getSjhm());
        map.put("yzm", domain.getYzm());
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxBdNsrBdCurr", "", map);
        returnDomain = new TaxCommonReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxBdNsrBsy(WdsxBdNsrBsyAppDomain domain) throws Exception {
        WdsxBdNsrBsyReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxBdNsrBsyList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxBdNsrBsyCurr", "wdsxBdNsrBsyList", map);
        ArrayList<WdsxBdNsrBsyDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxBdNsrBsyList");
        returnDomain = new WdsxBdNsrBsyReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxBdNsrBsyAdd(WdsxBdNsrBsyAddAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("xm", HstEncodeUtil.GBK2ISO(domain.getXm()));
        map.put("sfzhm", domain.getSfzhm());
        map.put("sjhm", domain.getSjhm());
        map.put("sflbDm", domain.getSflbDm());
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxBdNsrBsyAddCurr", "", map);
        returnDomain = new TaxCommonReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxBdnsrBsyDel(WdsxBdNsrBsyDelAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("bsyDjxh", domain.getBsyDjxh());
        map.put("sflbDm", domain.getSflbDm());
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxBdnsrBsyDelCurr", "", map);
        returnDomain = new TaxCommonReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxGrszGetPic(WdsxGrszGetPicAppDomain domain) throws Exception {
        WdsxGrszGetPicReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxGrszGetPicList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxGrszGetPicCurr", "wdsxGrszGetPicList", map);
        List<WdsxGrszGetPicDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxGrszGetPicList");
        for (WdsxGrszGetPicDomain tem : dataList) {
            tem.setPic(tem.getPic().replaceAll("\r\n", "").replaceAll("\\s", "\\+"));
        }
        returnDomain = new WdsxGrszGetPicReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxGrszPutPic(WdsxGrszPutPicAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain("00", "");
        HashMap<String, String> map = new HashMap<String, String>();
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        map.put("databaseUsername", databaseUsername);
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        String bsydjXh = (String)this.sqlMapClientTemplate.queryForObject("wdsxQueryBsydjXh", map);
        if (HstToolsUtil.isNullOrEmpty(bsydjXh)) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u8bf7\u60a8\u68c0\u67e5\uff0c\u7eb3\u7a0e\u4eba\u4eba\u5458\u4e0d\u5b58\u5728\u6216\u8005\u5df2\u5220\u9664\uff01");
            return returnDomain;
        }
        map.put("bsydjXh", bsydjXh);
        map.put("sfztxlbDm", domain.getSfztxlbDm());
        int num = (Integer)this.sqlMapClientTemplate.queryForObject("wdsxQuerySmzBsySfztx", map);
        SmzBsySfztx bo = new SmzBsySfztx();
        bo.setDatabaseUsername(databaseUsername);
        bo.setBsydjXh(bsydjXh);
        bo.setSfztxlbDm(domain.getSfztxlbDm());
        bo.setSjly("2");
        bo.setPic(domain.getPic().replaceAll("\r\n", "").replaceAll("\\s", "\\+"));
        bo.setCjrq(HstDateUtil.getCurrentDate());
        if (num > 0) {
            this.sqlMapClientTemplate.update("wdsxSmzBsySfztxUpate", bo);
        } else {
            this.sqlMapClientTemplate.insert("wdsxSmzBsySfztxSave", bo);
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxGrszUpdate(WdsxGrszUpdateAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("xm", HstEncodeUtil.GBK2ISO(domain.getXm()));
        map.put("xb", domain.getXb());
        map.put("csrq", domain.getCsrq());
        map.put("sjhm", domain.getSjhm());
        map.put("sfzhm", domain.getSfzhm());
        this.sqlMapClientTemplate.queryForObject("wdsxGrszUpdateCurr", map);
        returnDomain = new TaxCommonReturnDomain("00", "");
        return returnDomain;
    }

    public TaxCommonReturnDomain wdsxYjjySave(WdsxYjjySaveAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("yjjynr", HstEncodeUtil.UTF82ISO(domain.getYjjy()));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("yjjynr", HstEncodeUtil.UTF82GBK(domain.getYjjy()));
        }
        map.put("sfxyhf", "Y");
        map.put("yxbz", "Y");
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        map.put("databaseUsername", databaseUsername);
        this.sqlMapClientTemplate.insert("wdsxYjjySave", map);
        returnDomain = new TaxCommonReturnDomain("00", "");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wdsxYjjyList(WdsxYjjyListAppDomain domain) throws Exception {
        WdsxYjjyListReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getStr())) {
            map.put("str", "");
        } else {
            map.put("str", HstEncodeUtil.GBK2ISO(domain.getStr()));
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("code", "");
        map.put("mess", "");
        map.put("wdsxYjjyList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("wdsxYjjyListCurr", "wdsxYjjyList", map);
        ArrayList<WdsxYjjyListDomain> dataList = new ArrayList();
        dataList = (List)map.get("wdsxYjjyList");
        returnDomain = new WdsxYjjyListReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain yyfwCxZjxx(YyfwCxZjxxAppDomain domain) throws Exception {
        YyfwCxZjxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("yyfwsxDm", domain.getYyfwsxDm());
        this.sqlMapClientTemplate.queryForObjectByCurr("yyfwCxZjxxCurr", "dataList", map);
        ArrayList<YyfwCxZjxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new YyfwCxZjxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain yyfwCxZjyyfbsj(YyfwCxZjyyfbsjAppDomain domain) throws Exception {
        YyfwCxZjyyfbsjReturnDomain returnDomain = new YyfwCxZjyyfbsjReturnDomain();
        Connection conn = null;
        Statement cstmt = null;
        ResultSet rs = null;
        try {
            try {
                conn = this.sqlMapClientTemplate.getDataSource().getConnection();
            }
            catch (Exception e) {
                returnDomain.setCode("01");
                returnDomain.setMess(e.toString());
                _log.error((Object)e.toString());
                YyfwCxZjyyfbsjReturnDomain yyfwCxZjyyfbsjReturnDomain = returnDomain;
                if (rs != null) {
                    rs.close();
                }
                if (cstmt != null) {
                    cstmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
                return yyfwCxZjyyfbsjReturnDomain;
            }
            try {
                conn.setAutoCommit(false);
                String proc = "{call P_WEBJK_WXFW6512_CXZJYYFBSJ(?,?,?,?,?,?,?,?,?,?,?)}";
                cstmt = conn.prepareCall(proc);
                int parIndex = 1;
                cstmt.setString(parIndex++, domain.getSwjgDm());
                cstmt.setString(parIndex++, domain.getOpenId());
                cstmt.setString(parIndex++, domain.getCzryDm());
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 2005);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, 12);
                cstmt.registerOutParameter(parIndex++, -10);
                String parStrs = "[" + domain.getSwjgDm() + "," + domain.getOpenId() + "," + domain.getCzryDm() + "]";
                _log.info((Object)("\u6267\u884c\u5b58\u50a8\u8fc7\u7a0b\uff1a" + proc + ";\u53c2\u6570:" + parStrs));
                cstmt.execute();
                rs = (ResultSet)cstmt.getObject(11);
                ArrayList<YyfwCxZjyyfbsjDomain> dataList = new ArrayList<YyfwCxZjyyfbsjDomain>();
                while (rs.next()) {
                    YyfwCxZjyyfbsjDomain dom = new YyfwCxZjyyfbsjDomain();
                    dom.setCzryDm(rs.getString("CZRY_DM"));
                    dom.setRq(rs.getString("RQ"));
                    dom.setSxwbz(rs.getString("SXWBZ"));
                    dom.setRsMax(rs.getString("RS_MAX"));
                    dom.setRsYyy(rs.getString("RS_YYY"));
                    dom.setRsKyy(rs.getString("RS_KYY"));
                    dataList.add(dom);
                }
                String czryMc = cstmt.getString(4);
                String swbmDm = cstmt.getString(5);
                String swbmMc = cstmt.getString(6);
                String zcms = cstmt.getString(7);
                String headPic = cstmt.getString(8);
                String code = cstmt.getString(9);
                String mess = cstmt.getString(10);
                returnDomain.setCzryDm(domain.getCzryDm());
                returnDomain.setCzryMc(HstToolsUtil.ISO2GBK(czryMc));
                returnDomain.setSwbmDm(swbmDm);
                returnDomain.setSwbmMc(HstToolsUtil.ISO2GBK(swbmMc));
                returnDomain.setZcms(HstToolsUtil.ISO2GBK(zcms));
                returnDomain.setHeadPic(HstToolsUtil.ISO2GBK(headPic));
                returnDomain.setCode(code);
                returnDomain.setMess(HstToolsUtil.ISO2GBK(mess));
                returnDomain.setDataList(dataList);
                conn.commit();
            }
            catch (Exception e) {
                conn.rollback();
                returnDomain.setCode("01");
                returnDomain.setMess(e.toString());
                _log.error((Object)e.toString());
                YyfwCxZjyyfbsjReturnDomain yyfwCxZjyyfbsjReturnDomain = returnDomain;
                return yyfwCxZjyyfbsjReturnDomain;
            }
        }
        finally {
            if (rs != null) {
                rs.close();
            }
            if (cstmt != null) {
                cstmt.close();
            }
            if (conn != null) {
                conn.close();
            }
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain yyfwSaveYyxx(YyfwSaveYyxxAppDomain domain) throws Exception {
        YyfwSaveYyxxReturnDomain returnDomain = new YyfwSaveYyxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("czryDm", domain.getCzryDm());
        map.put("rq", domain.getRq());
        map.put("sxwbz", domain.getSxwbz());
        map.put("yywtms", HstEncodeUtil.GBK2ISO(domain.getYywtms()));
        this.sqlMapClientTemplate.queryForObject("YyfwSaveYyxxCurr", map);
        returnDomain.setYyfwXh((String)map.get("yyfwXh"));
        returnDomain.setYysxh((String)map.get("yysxh"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain yyfwCxWyyyxx(YyfwCxWyyyxxAppDomain domain) throws Exception {
        YyfwCxWyyyxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.sqlMapClientTemplate.queryForObjectByCurr("YyfwCxWyyyxxCurr", "dataList", map);
        ArrayList<YyfwCxWyyyxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new YyfwCxWyyyxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain yyfwQxyyfw(YyfwQxyyfwAppDomain domain) throws Exception {
        YyfwQxyyfwReturnDomain returnDomain = new YyfwQxyyfwReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        map.put("databaseUsername", databaseUsername);
        map.put("swjgDm", domain.getSwjgDm());
        map.put("yyfwXh", domain.getYyfwXh());
        map.put("openId", domain.getOpenId());
        this.sqlMapClientTemplate.queryForObject("yyfwQxyyfw", map);
        returnDomain.setCode("00");
        return returnDomain;
    }

    public TaxCommonReturnDomain pubGetBsdt(PubGetBsdtAppDomain domain) throws Exception {
        PubGetBsdtReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        this.sqlMapClientTemplate.queryForObjectByCurr("PubGetBsdtCurr", "dataList", map);
        ArrayList<PubGetBsdtDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new PubGetBsdtReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain wjzSaveSqxx(WjzSaveSqxxAppDomain domain) throws Exception {
        WjzSaveSqxxReturnDomain returnDomain = new WjzSaveSqxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getNsrsbh());
        NsrxxDomain nsr = (NsrxxDomain)this.ssglSqlMapClientTemplate.queryForObject("getNsrxxByNsrsbh", map);
        if (nsr == null) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u7eb3\u7a0e\u4eba\u4e0d\u5b58\u5728");
            return returnDomain;
        }
        String wsDjhzXh = HstToolsUtil.getSequence(this.ssglSqlMapClientTemplate.getDataSource().getConnection(), "SEQ_WS_DJHZ");
        SssxSlsqSqrxx sqrxx = new SssxSlsqSqrxx();
        sqrxx.setNsrbsh(domain.getNsrsbh());
        sqrxx.setXm(domain.getLxr());
        sqrxx.setSjhm(domain.getLxdh());
        sqrxx.setCjrq(HstDateUtil.getCurrentDate());
        sqrxx.setYxbz("Y");
        this.saveSssxSqrxx(sqrxx);
        SssxSlhz sssx = new SssxSlhz();
        sssx.setSssxDm("110037");
        sssx.setUrl("urlTest");
        sssx.setNsrsbh(domain.getNsrsbh());
        sssx.setNsrmc(domain.getNsrmc());
        sssx.setNsrdzdah(nsr.getNsrdzdah());
        sssx.setNsrSwjgDm(nsr.getNsrSwjgDm());
        sssx.setJbdm(nsr.getJbdm());
        sssx.setLrrq(HstDateUtil.getCurrentDate());
        sssx.setSqbz("0");
        sssx.setSlfs("3");
        sssx.setSlztDm("20");
        sssx.setYxbz("Y");
        sssx.setSqrq(HstDateUtil.getCurrentDate());
        sssx.setLxrDjxh(sqrxx.getDjxxXh());
        sssx.setSlbh(wsDjhzXh);
        sssx.setSqrid(domain.getOpenId());
        sssx.setWsDjhzXh(wsDjhzXh);
        this.ssglSqlMapClientTemplate.insert("insertSssxSlhz", sssx);
        WsDjhz wsbo = new WsDjhz();
        wsbo.setWsDjhzXh(wsDjhzXh);
        wsbo.setNsrsbh(domain.getNsrsbh());
        wsbo.setNsrdzdah(nsr.getNsrdzdah());
        wsbo.setNsrSwjgDm(nsr.getNsrSwjgDm());
        wsbo.setJbdm(nsr.getJbdm());
        wsbo.setWsDm("021110");
        wsbo.setUrl("url");
        wsbo.setBcbz("1");
        wsbo.setLsbz("N");
        wsbo.setSxbz("2");
        wsbo.setUrl("/dkfpsq/sqwsly!initMx?domain.wsDjhzXh=" + wsDjhzXh);
        wsbo.setCjrDm("99999999999");
        wsbo.setCjrq(HstDateUtil.getSqlDate().toString());
        wsbo.setXgrDm("99999999999");
        wsbo.setXgrq(HstDateUtil.getSqlDate().toString());
        wsbo.setYxbz("Y");
        wsbo.setSssxSlxh(sssx.getSssxSlxh());
        wsbo.setSssxDm("110037");
        wsbo.setUrlEdit("/bspt2/dkfpsq/wcjyhdssglzm!initMx.action?domain.wsDjhzXh=" + wsDjhzXh);
        wsbo.setUrlPrint("/bspt2/dkfpsq/wcjyhdssglzm!print.action?domain.wsDjhzXh=" + wsDjhzXh);
        wsbo.setUrlView("/bspt2/dkfpsq/wcjyhdssglzm!queryMx.action?domain.wsDjhzXh=" + wsDjhzXh);
        this.ssglSqlMapClientTemplate.insert("insertWsDjhz", wsbo);
        SssxSlsqws slsqws = new SssxSlsqws();
        slsqws.setWsDjhzXh(wsbo.getWsDjhzXh());
        slsqws.setSssxSlxh(sssx.getSssxSlxh());
        this.ssglSqlMapClientTemplate.insert("insertSssxSlsqws", slsqws);
        WsDjWjzkjsq wjzkjsq = new WsDjWjzkjsq();
        wjzkjsq.setWsDjhzXh(wsDjhzXh);
        wjzkjsq.setNsrsbh(domain.getNsrsbh());
        wjzkjsq.setNsrmc(domain.getNsrmc());
        wjzkjsq.setFrxm(domain.getFrxm());
        wjzkjsq.setSfzjmc(domain.getSfzjmc());
        wjzkjsq.setSfzjhm(domain.getSfzjhm());
        wjzkjsq.setLxr(domain.getLxr());
        wjzkjsq.setLxdh(domain.getLxdh());
        wjzkjsq.setDjzclxMc(domain.getDjzclxMc());
        wjzkjsq.setSwdjd(domain.getSwdjd());
        wjzkjsq.setWcjydlx(domain.getWcjydlx());
        wjzkjsq.setWcjyd(domain.getWcjyd());
        wjzkjsq.setYxqQ(domain.getYxqq());
        wjzkjsq.setYxqZ(domain.getYxqz());
        wjzkjsq.setJyfs(domain.getJyfs());
        wjzkjsq.setXmmc(domain.getXmmc());
        wjzkjsq.setHtje(domain.getHtje());
        wjzkjsq.setSqrq(domain.getSqrq());
        wjzkjsq.setSqrq(wsDjhzXh);
        wjzkjsq.setYxbz("Y");
        wjzkjsq.setWjzSqdbh(wsDjhzXh);
        this.ssglSqlMapClientTemplate.insert("insertWsDjWjzkjsq", wjzkjsq);
        if (domain.getDataList().isEmpty()) {
            WsDjWjzkjsqZb sqzb = new WsDjWjzkjsqZb();
            sqzb.setXh("1");
            if ("1".equals(domain.getJyfs())) {
                sqzb.setXmlx("2");
            } else {
                sqzb.setXmlx("1");
            }
            sqzb.setMc(domain.getXmmc());
            sqzb.setDd(domain.getWcjyd());
            sqzb.setSl("1");
            sqzb.setJe(domain.getHtje());
            sqzb.setWsDjhzXh(wsDjhzXh);
            this.ssglSqlMapClientTemplate.insert("insertWsDjWjzkjsqZb", sqzb);
        } else {
            for (WjzSaveSqxxDomain dom : domain.getDataList()) {
                WsDjWjzkjsqZb sqzb = new WsDjWjzkjsqZb();
                BeanUtils.copyProperties((Object)sqzb, (Object)dom);
                sqzb.setWsDjhzXh(wsDjhzXh);
                this.ssglSqlMapClientTemplate.insert("insertWsDjWjzkjsqZb", sqzb);
            }
        }
        returnDomain.setCode("00");
        returnDomain.setSssxSlxh(sssx.getSssxSlxh());
        returnDomain.setWjDjhzxh(wsDjhzXh);
        return returnDomain;
    }

    public TaxCommonReturnDomain gkdhCx(GkdhCxAppDomain domain) throws Exception {
        GkdhCxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        this.sqlMapClientTemplate.queryForObjectByCurr("GkdhCxCurr", "dataList", map);
        ArrayList<GkdhCxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new GkdhCxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain qympXhfzc(QympXhfzcAppDomain domain) throws Exception {
        QympXhfzcReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("xhfnsrsbh", domain.getXhfnsrsbh());
        map.put("xhfnsrmc", HstEncodeUtil.GBK2ISO(domain.getXhfnsrmc()));
        map.put("xhfdz", HstEncodeUtil.GBK2ISO(domain.getXhfdz()));
        map.put("xhfdh", domain.getXhfdh());
        map.put("xhfkhyh", HstEncodeUtil.GBK2ISO(domain.getXhfkhyh()));
        map.put("xhfyhzh", domain.getXhfyhzh());
        domain.setInZcuuid(EjbJ3Util.getUUID());
        map.put("inZcuuid", domain.getInZcuuid());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("QympXhfzcCurr", map, new String[0]);
        returnDomain = new QympXhfzcReturnDomain();
        returnDomain.setOutZcuuid((String)map.get("outZcuuid"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain qympGhfKprGet(QympGhfKprGetAppDomain domain) throws Exception {
        QympGhfKprGetReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("QympGhfKprGetCurr", map, new String[0]);
        returnDomain = new QympGhfKprGetReturnDomain();
        returnDomain.setSjhm(HstToolsUtil.ISO2GBK((String)map.get("sjhm")));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain qympGhfDjxxGet(QympGhfDjxxGetAppDomain domain) throws Exception {
        QympGhfDjxxGetReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("sjhm", domain.getSjhm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("QympGhfDjxxGetCurr", "dataList", map);
        ArrayList<QympGhfDjxxGetDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new QympGhfDjxxGetReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain qympGhfDjxxDel(QympGhfDjxxDelAppDomain domain) throws Exception {
        QympGhfDjxxDelReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("ghfDjxh", domain.getGhfDjxh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("QympGhfDjxxDelCurr", map, new String[0]);
        returnDomain = new QympGhfDjxxDelReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain qympGhfDjxxJhClose(QympGhfDjxxJhCloseAppDomain domain) throws Exception {
        QympGhfDjxxJhCloseReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("ghfDjxh", domain.getGhfDjxh());
        map.put("sjhm", domain.getSjhm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("QympGhfDjxxJhCloseCurr", map, new String[0]);
        returnDomain = new QympGhfDjxxJhCloseReturnDomain();
        returnDomain.setJhbz(HstToolsUtil.ISO2GBK((String)map.get("jhbz")));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain zgswjgCx(ZgswjgCxAppDomain domain) throws Exception {
        ZgswjgCxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        this.sqlMapClientTemplate.queryForObject("ZgswjgCx", map);
        returnDomain = new ZgswjgCxReturnDomain();
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setSwjgmc(HstToolsUtil.ISO2GBK((String)map.get("swjgmc")));
        returnDomain.setSwbmmc(HstToolsUtil.ISO2GBK((String)map.get("swbmmc")));
        returnDomain.setLxdh((String)map.get("lxdh"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain zgswgyCx(ZgswgyCxAppDomain domain) throws Exception {
        ZgswgyCxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        this.sqlMapClientTemplate.queryForObject("ZgswgyCxCurr", map);
        returnDomain = new ZgswgyCxReturnDomain();
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setGlyxm(HstToolsUtil.ISO2GBK((String)map.get("glyxm")));
        returnDomain.setSzks(HstToolsUtil.ISO2GBK((String)map.get("szks")));
        returnDomain.setBgs(HstToolsUtil.ISO2GBK((String)map.get("bgs")));
        returnDomain.setBgsdh(HstToolsUtil.ISO2GBK((String)map.get("bgsdh")));
        returnDomain.setSjhm((String)map.get("sjhm"));
        returnDomain.setQtlxfs((String)map.get("qtlxfs"));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain stpxCxKcxx(StpxCxKcxxAppDomain domain) throws Exception {
        StpxCxKcxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.sqlMapClientTemplate.queryForObjectByCurr("StpxCxKcxxCurr", "dataList", map);
        ArrayList<StpxCxKcxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new StpxCxKcxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain stpxCxKcxxxx(StpxCxKcxxxxAppDomain domain) throws Exception {
        StpxCxKcxxxxReturnDomain returnDomain = new StpxCxKcxxxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("pxkcXh", domain.getPxkcXh());
        this.sqlMapClientTemplate.queryForObjectByCurr("StpxCxKcxxxxCurr", "dataList", map);
        ArrayList<StpxCxKcxxxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain.setPxkcXh(domain.getPxkcXh());
        returnDomain.setSsSwjgmc(HstToolsUtil.ISO2GBK((String)map.get("ssSwjgmc")));
        returnDomain.setPxdx(HstToolsUtil.ISO2GBK((String)map.get("pxdx")));
        returnDomain.setPxnr(HstToolsUtil.ISO2GBK((String)map.get("pxnr")));
        returnDomain.setPxsj(HstToolsUtil.ISO2GBK((String)map.get("pxsj")));
        returnDomain.setPxdd(HstToolsUtil.ISO2GBK((String)map.get("pxdd")));
        returnDomain.setBmjzrq((String)map.get("bmjzrq"));
        returnDomain.setMaxbms((String)map.get("maxbms"));
        returnDomain.setYbmsl((String)map.get("ybmsl"));
        returnDomain.setZzdw((String)map.get("Zzdw"));
        returnDomain.setSfwdwbm((String)map.get("sfwdwbm"));
        returnDomain.setSfgrbm((String)map.get("sfgrbm"));
        returnDomain.setSfdrcbm((String)map.get("sfdrcbm"));
        returnDomain.setKcztDm((String)map.get("kcztDm"));
        returnDomain.setKcztMc(HstToolsUtil.ISO2GBK((String)map.get("kcztMc")));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain stpxSaveBmxx(StpxSaveBmxxAppDomain domain) throws Exception {
        StpxSaveBmxxReturnDomain returnDomain = new StpxSaveBmxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openid", domain.getOpenId());
        map.put("pxkcXh", domain.getPxkcXh());
        Integer count = (Integer)this.sqlMapClientTemplate.queryForObject("selectCountNsfwStpxPxkcBmmd", map);
        if (count > 0) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u60a8\u5df2\u62a5\u540d\u8be5\u8bfe\u7a0b");
            return returnDomain;
        }
        NsfwStpxPxkcBmmd bo = new NsfwStpxPxkcBmmd();
        bo.setPxkcXh(domain.getPxkcXh());
        bo.setOpenId(domain.getOpenId());
        bo.setGrbz(domain.getGrbz());
        bo.setNsrsbh(domain.getNsrsbh());
        bo.setXm(domain.getXm());
        bo.setSjhm(domain.getSjhm());
        bo.setYxdz(domain.getEmail());
        bo.setBmfs(domain.getBmfs());
        bo.setMdqrbz("N");
        bo.setQdbz("N");
        bo.setYxbz("Y");
        this.sqlMapClientTemplate.insert("insertPxkcKcbm", bo);
        map.put("pxkcbmXh", bo.getPxkcbmXh());
        this.sqlMapClientTemplate.queryForObject("StpxSaveBmxxCurr", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        if (!"00".equals(returnDomain.getCode())) {
            throw new ServiceException();
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain stpxCxYbmkc(StpxCxYbmkcAppDomain domain) throws Exception {
        StpxCxYbmkcReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("sjhm", domain.getSjhm());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.sqlMapClientTemplate.queryForObjectByCurr("StpxCxYbmkcCurr", "dataList", map);
        ArrayList<StpxCxYbmkcDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new StpxCxYbmkcReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain stpxSaveYjyj(StpxSaveYjyjAppDomain domain) throws Exception {
        StpxSaveYjyjReturnDomain returnDomain = new StpxSaveYjyjReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("pxkcbmXh", domain.getPxkcbmXh());
        Integer count = (Integer)this.sqlMapClientTemplate.queryForObject("selectCountPxkcYjjy", map);
        if (count > 0) {
            NsfwStpxPxkcYjjy bo = new NsfwStpxPxkcYjjy();
            bo.setPxkcXh(domain.getPxkcXh());
            bo.setPxkcbmXh(domain.getPxkcbmXh());
            bo.setYjjy(domain.getYjjy());
            bo.setDjrq(HstDateUtil.getCurrentDate());
            this.sqlMapClientTemplate.insert("updatePxkcYjjy", bo);
        } else {
            NsfwStpxPxkcYjjy bo = new NsfwStpxPxkcYjjy();
            bo.setPxkcXh(domain.getPxkcXh());
            bo.setPxkcbmXh(domain.getPxkcbmXh());
            bo.setYjjy(domain.getYjjy());
            bo.setDjrq(HstDateUtil.getCurrentDate());
            this.sqlMapClientTemplate.insert("insertPxkcYjjy", bo);
        }
        returnDomain.setCode("00");
        return returnDomain;
    }

    public TaxCommonReturnDomain stpxCxPjnr(StpxCxPjnrAppDomain domain) throws Exception {
        StpxCxPjnrReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("pxkcXh", domain.getPxkcXh());
        this.sqlMapClientTemplate.queryForObjectByCurr("StpxCxPjnrCurr", "dataList", map);
        ArrayList<StpxCxPjnrDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new StpxCxPjnrReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain stpxSavePjnr(StpxSavePjnrAppDomain domain) throws Exception {
        StpxSavePjnrReturnDomain returnDomain = new StpxSavePjnrReturnDomain();
        if (domain.getDataList().isEmpty()) {
            returnDomain.setCode("01");
            returnDomain.setMess("dataLsit\u6570\u636e\u4f20\u5165\u4e3a\u7a7a");
            return returnDomain;
        }
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("pxkcbmXh", domain.getPxkcbmXh());
        this.sqlMapClientTemplate.delete("deleteNsfwStpxPxkcPjByPxkcbmxh", map);
        for (StpxSavePjnrDomain dom : domain.getDataList()) {
            NsfwStpxPxkcPj bo = new NsfwStpxPxkcPj();
            bo.setPxkcXh(domain.getPxkcXh());
            bo.setPxkcbmXh(domain.getPxkcbmXh());
            bo.setPjfs(domain.getPjfs());
            bo.setPjwtDm(dom.getPjwtDm());
            bo.setXxxh(dom.getXxxh());
            bo.setBz(dom.getBz());
            bo.setPjrq(HstDateUtil.getCurrentDate());
            this.sqlMapClientTemplate.insert("insertPxkcPj", bo);
        }
        returnDomain.setCode("00");
        return returnDomain;
    }

    public TaxCommonReturnDomain pubPutUserMess(PubPutUserMessAppDomain domain) throws Exception {
        PubPutUserMessReturnDomain returnDomain = new PubPutUserMessReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        map.put("databaseUsername", databaseUsername);
        FwhSwjgZhxxGr dom = (FwhSwjgZhxxGr)this.sqlMapClientTemplate.queryForObject("selectFwhSwjgZhxxGr", map);
        FwhSwjgZhxxGr bo = new FwhSwjgZhxxGr();
        BeanUtils.copyProperties((Object)bo, (Object)domain);
        bo.setYxbz("Y");
        bo.setDatabaseUsername(databaseUsername);
        if (dom == null) {
            this.sqlMapClientTemplate.insert("insertFwhSwjgZhxxGr", bo);
        } else {
            this.sqlMapClientTemplate.update("updateFwhSwjgZhxxGr", bo);
        }
        returnDomain.setCode("00");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wjzCxYsqxx(WjzCxYsqxxAppDomain domain) throws Exception {
        WjzCxYsqxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.sqlMapClientTemplate.queryForObjectByCurr("WjzCxYsqxxCurr", "dataList", map);
        ArrayList<WjzCxYsqxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new WjzCxYsqxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain wjzQxsq(WjzQxsqAppDomain domain) throws Exception {
        WjzQxsqReturnDomain returnDomain = new WjzQxsqReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("wsDjhzXh", domain.getWjDjhzxh());
        map.put("sssxSlxh", domain.getSssxSlxh());
        this.sqlMapClientTemplate.queryForObject("WjzQxsqCurr", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain wjzCheckSqzg(WjzCheckSqzgAppDomain domain) throws Exception {
        WjzCheckSqzgReturnDomain returnDomain = new WjzCheckSqzgReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        this.sqlMapClientTemplate.queryForObjectByCurr("WjzCheckSqzgCurr", "dataList", map);
        List dataList = (List)map.get("dataList");
        if ("00".equals((String)map.get("code"))) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpjylxCheckSqzg(FpjylxCheckSqzgAppDomain domain) throws Exception {
        FpjylxCheckSqzgReturnDomain returnDomain = new FpjylxCheckSqzgReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        this.sqlMapClientTemplate.queryForObjectByCurr("fpjylxCheckSqzgCurr", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        if (!"00".equals(returnDomain.getCode())) {
            return returnDomain;
        }
        returnDomain.setDataList(dataList);
        returnDomain.setNsrsbh(domain.getNsrsbh());
        returnDomain.setNsrmc(HstEncodeUtil.ISO2GBK((String)map.get("nsrmc")));
        returnDomain.setZgswjgDm(HstEncodeUtil.ISO2GBK((String)map.get("zgswjgDm")));
        returnDomain.setZgswjgMc(HstEncodeUtil.ISO2GBK((String)map.get("zgswjgMc")));
        returnDomain.setFpjbrxm(HstEncodeUtil.ISO2GBK((String)map.get("fpjbrxm")));
        returnDomain.setFpjbrsfzh(HstEncodeUtil.ISO2GBK((String)map.get("fpjbrsfz")));
        returnDomain.setYjxxSjhm(HstEncodeUtil.ISO2GBK((String)map.get("yjsjhm")));
        returnDomain.setSfyxhfpyj(HstEncodeUtil.ISO2GBK((String)map.get("sfyxhfp")));
        NsrxxDomain yjxxDomain = (NsrxxDomain)this.sqlMapClientTemplate.queryForObject("selectFpyjCheckNsrYjxx", map);
        HashSet<String> nsrdzList = new HashSet<String>();
        HashSet<String> nsryjxmList = new HashSet<String>();
        if (yjxxDomain != null) {
            if (StringUtils.isNotBlank((String)yjxxDomain.getScjydz())) {
                nsrdzList.add(yjxxDomain.getScjydz());
            }
            if (StringUtils.isNotBlank((String)yjxxDomain.getZcdz())) {
                nsrdzList.add(yjxxDomain.getZcdz());
            }
            if (StringUtils.isNotBlank((String)yjxxDomain.getFddbrmc())) {
                nsryjxmList.add(yjxxDomain.getFddbrmc());
            }
            if (StringUtils.isNotBlank((String)yjxxDomain.getCwfzrmc())) {
                nsryjxmList.add(yjxxDomain.getCwfzrmc());
            }
            if (StringUtils.isNotBlank((String)yjxxDomain.getBsrmc())) {
                nsryjxmList.add(yjxxDomain.getBsrmc());
            }
        }
        List whdzList = this.ssglSqlMapClientTemplate.queryForList("selectFpyjCheckWhDzList", map);
        int i = 0;
        while (i < whdzList.size()) {
            whdzList.set(i, new String(((String)whdzList.get(i)).getBytes("ISO_8859_1"), "GBK"));
            ++i;
        }
        whdzList.addAll(nsrdzList);
        returnDomain.getYjxm().addAll(nsryjxmList);
        returnDomain.setYjdz(whdzList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpjylxCxNsrPzxx(FpjylxCxNsrPzxxAppDomain domain) throws Exception {
        FpjylxCxNsrPzxxReturnDomain returnDomain = new FpjylxCxNsrPzxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        this.sqlMapClientTemplate.queryForObjectByCurr("FpjylxCxNsrPzxxCurr", "dataList", map);
        List<FpjylxCxNsrPzxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        for (FpjylxCxNsrPzxxDomain dom : dataList) {
            if (dom.getFpzlDm().equals("71149")) {
                dom.setDw("1");
                continue;
            }
            dom.setDw("2");
        }
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpjylxCxNsrJcxx(FpjylxCxNsrJcxxAppDomain domain) throws Exception {
        FpjylxCxNsrJcxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        this.sqlMapClientTemplate.queryForObjectByCurr("FpjylxCxNsrJcxxCurr", "dataList", map);
        ArrayList<FpjylxCxNsrJcxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new FpjylxCxNsrJcxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpjylxCxNsrDylgxx(FpjylxCxNsrDylgxxAppDomain domain) throws Exception {
        FpjylxCxNsrDylgxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("ssyf", domain.getSsyf());
        this.sqlMapClientTemplate.queryForObjectByCurr("fpjylxCxNsrDylgxxCurr", "dataList", map);
        ArrayList<FpjylxCxNsrDylgxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new FpjylxCxNsrDylgxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpjylxCxNsrFpyjxx(FpjylxCxNsrFpyjxxAppDomain domain) throws Exception {
        FpjylxCxNsrFpyjxxReturnDomain returnDomain = new FpjylxCxNsrFpyjxxReturnDomain();
        Connection conn = null;
        Statement cstmt = null;
        ResultSet rs = null;
        ArrayList<FpjylxCxNsrFpyjxxDomain> dataList = new ArrayList<FpjylxCxNsrFpyjxxDomain>();
        for (FpjylxCxNsrFpyjxxDomain parDom : domain.getDataList()) {
            try {
                try {
                    conn = OracleUtil.getConnection(WebConstants.FWSK_IP, WebConstants.FWSK_SID, WebConstants.FWSK_PORT, WebConstants.FWSK_USERNAME, WebConstants.FWSK_PASSWORD);
                }
                catch (Exception exception) {
                    returnDomain.setCode("01");
                    returnDomain.setMess("\u7cfb\u7edf\u9519\u8bef\uff0c\u65e0\u6cd5\u83b7\u53d6\u9632\u4f2a\u7a0e\u63a7\u6570\u636e,\u8bf7\u7a0d\u5019\u518d\u8bd5\uff01");
                    FpjylxCxNsrFpyjxxReturnDomain fpjylxCxNsrFpyjxxReturnDomain = returnDomain;
                    if (rs != null) {
                        rs.close();
                    }
                    if (cstmt != null) {
                        cstmt.close();
                    }
                    if (conn != null) {
                        conn.close();
                    }
                    return fpjylxCxNsrFpyjxxReturnDomain;
                }
                try {
                    conn.setAutoCommit(false);
                    String proc = "{? = call HTJS.P_GET_FWSK_BSXX_HMDYJ(?,?,?,?,?,?,?)}";
                    int parIndex = 1;
                    cstmt = conn.prepareCall(proc);
                    cstmt.registerOutParameter(parIndex++, 4);
                    cstmt.setString(parIndex++, domain.getNsrsbh());
                    cstmt.setString(parIndex++, this.selectFplbDm(parDom.getFpzlDm()));
                    cstmt.setString(parIndex++, parDom.getFpDm());
                    cstmt.setString(parIndex++, parDom.getFpqh());
                    cstmt.setString(parIndex++, parDom.getFpzh());
                    cstmt.registerOutParameter(parIndex++, -10);
                    cstmt.registerOutParameter(parIndex++, 12);
                    cstmt.execute();
                    int rint = cstmt.getInt(1);
                    rs = (ResultSet)cstmt.getObject(7);
                    if (rint == 100) {
                        while (rs.next()) {
                            FpjylxCxNsrFpyjxxDomain dom = new FpjylxCxNsrFpyjxxDomain();
                            dom.setFpzlDm(parDom.getFpzlDm());
                            dom.setFpDm(rs.getString("AVC_FPDM"));
                            dom.setFpqh(rs.getString("AVC_FPQH"));
                            dom.setFpzh(rs.getString("AVC_FPZH"));
                            dom.setFs(rs.getString("FS"));
                            dom.setJe(rs.getString("AN_JE"));
                            dom.setSe(rs.getString("AN_SE"));
                            dom.setFpYjjgDm(rs.getString("AC_FPTKZT"));
                            dom.setRqQ(rs.getString("AVC_KPRQQ"));
                            dom.setRqZ(rs.getString("AVC_KPRQZ"));
                            dataList.add(dom);
                        }
                    } else {
                        this.queryPtfpAndHyz(domain, parDom, dataList);
                    }
                    conn.commit();
                }
                catch (Exception e) {
                    conn.rollback();
                    e.printStackTrace();
                    throw e;
                }
            }
            finally {
                if (rs != null) {
                    rs.close();
                }
                if (cstmt != null) {
                    cstmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
            }
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode("00");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    protected void queryPtfpAndHyz(FpjylxCxNsrFpyjxxAppDomain domain, FpjylxCxNsrFpyjxxDomain parDom, List<FpjylxCxNsrFpyjxxDomain> dataList) throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("fpzlDm", parDom.getFpzlDm());
        map.put("fpDm", parDom.getFpDm());
        map.put("fpqh", parDom.getFpqh());
        map.put("fpzh", parDom.getFpzh());
        map.put("nsrfpyjxxList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6312Fpyjxx", "dataList", map);
        List domList = (List)map.get("nsrfpyjxxList");
        if (domList != null && !domList.isEmpty()) {
            dataList.addAll(domList);
        }
    }

    public String selectFplbDm(String fpzlDm) throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("fpzlDm", fpzlDm);
        return (String)this.sqlMapClientTemplate.queryForObject("selectFplbDmByFpzlDm", map);
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpjylxSaveSqxx(FpjylxSaveSqxxAppDomain domain) throws Exception {
        FpjylxSaveSqxxReturnDomain returnDomain = new FpjylxSaveSqxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getNsrsbh());
        NsrxxDomain nsr = (NsrxxDomain)this.ssglSqlMapClientTemplate.queryForObject("getNsrxxByNsrsbh", map);
        if (nsr == null) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u7eb3\u7a0e\u4eba\u4e0d\u5b58\u5728");
            return returnDomain;
        }
        String wsDjhzXh = HstToolsUtil.getSequence(this.ssglSqlMapClientTemplate.getDataSource().getConnection(), "SEQ_WS_DJHZ");
        SssxSlsqSqrxx sqrxx = new SssxSlsqSqrxx();
        sqrxx.setNsrbsh(domain.getNsrsbh());
        sqrxx.setXm(domain.getLxrXm());
        sqrxx.setSjhm(domain.getLxrSjhm());
        sqrxx.setGddh(domain.getLxrGddh());
        sqrxx.setCjrq(HstDateUtil.getCurrentDate());
        sqrxx.setYxbz("Y");
        this.saveSssxSqrxx(sqrxx);
        SssxSlsqSqrYjxx yjxx = new SssxSlsqSqrYjxx();
        yjxx.setNsrbsh(domain.getNsrsbh());
        yjxx.setDz(domain.getYjdz());
        yjxx.setGddh(domain.getYjdddh());
        yjxx.setSjhm(domain.getYjsjhm());
        yjxx.setSjr(domain.getYjxm());
        yjxx.setYb(domain.getYjyb());
        yjxx.setYxbz("Y");
        yjxx.setCjrq(HstDateUtil.getCurrentDate());
        this.saveSssxYjxx(yjxx);
        SssxSlhz sssx = new SssxSlhz();
        sssx.setSssxDm("130017");
        sssx.setUrl("urlTest");
        sssx.setNsrsbh(domain.getNsrsbh());
        sssx.setNsrmc(nsr.getNsrmc());
        sssx.setNsrdzdah(nsr.getNsrdzdah());
        sssx.setNsrSwjgDm(nsr.getNsrSwjgDm());
        sssx.setJbdm(nsr.getJbdm());
        sssx.setLrrq(HstDateUtil.getCurrentDate());
        sssx.setSqbz("0");
        sssx.setSlfs("3");
        sssx.setSlztDm("20");
        sssx.setYxbz("Y");
        sssx.setSqrq(HstDateUtil.getCurrentDate());
        sssx.setLxrDjxh(sqrxx.getDjxxXh());
        sssx.setYjdzDjxxXh(yjxx.getDjxxXh());
        sssx.setSlbh(wsDjhzXh);
        sssx.setWsDjhzXh(wsDjhzXh);
        sssx.setSqrid(domain.getOpenId());
        this.ssglSqlMapClientTemplate.insert("insertSssxSlhz", sssx);
        WsDjhz wsbo = new WsDjhz();
        wsbo.setWsDjhzXh(wsDjhzXh);
        wsbo.setNsrsbh(domain.getNsrsbh());
        wsbo.setNsrdzdah(nsr.getNsrdzdah());
        wsbo.setNsrSwjgDm(nsr.getNsrSwjgDm());
        wsbo.setJbdm(nsr.getJbdm());
        wsbo.setWsDm("021920");
        wsbo.setUrl("url");
        wsbo.setBcbz("1");
        wsbo.setLsbz("N");
        wsbo.setSxbz("2");
        wsbo.setUrl("/dkfpsq/sqwsly!initMx?domain.wsDjhzXh=" + wsDjhzXh);
        wsbo.setCjrDm("99999999999");
        wsbo.setCjrq(HstDateUtil.getSqlDate().toString());
        wsbo.setXgrDm("99999999999");
        wsbo.setXgrq(HstDateUtil.getSqlDate().toString());
        wsbo.setYxbz("Y");
        wsbo.setSssxSlxh(sssx.getSssxSlxh());
        wsbo.setSssxDm("130017");
        wsbo.setUrlEdit("/bspt2/dkfpsq/nsrwsfpyjlgsq!initMx.action?domain.wsDjhzXh=" + wsDjhzXh);
        wsbo.setUrlPrint("/bspt2/dkfpsq/nsrwsfpyjlgsq!print.action?domain.wsDjhzXh=" + wsDjhzXh);
        wsbo.setUrlView("/bspt2/dkfpsq/nsrwsfpyjlgsq!queryMx.action?domain.wsDjhzXh=" + wsDjhzXh);
        this.ssglSqlMapClientTemplate.insert("insertWsDjhz", wsbo);
        SssxSlsqws slsqws = new SssxSlsqws();
        slsqws.setWsDjhzXh(wsbo.getWsDjhzXh());
        slsqws.setSssxSlxh(sssx.getSssxSlxh());
        this.ssglSqlMapClientTemplate.insert("insertSssxSlsqws", slsqws);
        NsfwWsgpSqzb sqzb = new NsfwWsgpSqzb();
        sqzb.setWsDjhzXh(wsDjhzXh);
        sqzb.setWsgpSqlxDm(domain.getWsgpSqlxDm());
        sqzb.setWsgpSqlbDm(domain.getWsgpSqlbDm());
        sqzb.setNsrsbh(domain.getNsrsbh());
        sqzb.setNsrdzdah(nsr.getNsrdzdah());
        sqzb.setSqrq(HstDateUtil.getCurrentDate());
        sqzb.setGpyxm(domain.getGpyxm());
        sqzb.setGpysfzm(domain.getGpysfzm());
        if ("3".equals(domain.getWsgpSqlxDm())) {
            sqzb.setWsgpSqlbDm("2");
            domain.setWsgpSqlbDm("2");
        }
        String wsgpSqdbh = "";
        wsgpSqdbh = "1".equals(domain.getWsgpSqlbDm()) ? "GA" + wsDjhzXh.substring(wsDjhzXh.length() - 12, wsDjhzXh.length()) : ("2".equals(domain.getWsgpSqlbDm()) ? "GB" + wsDjhzXh.substring(wsDjhzXh.length() - 12, wsDjhzXh.length()) : "GC" + wsDjhzXh.substring(wsDjhzXh.length() - 12, wsDjhzXh.length()));
        sqzb.setWsgpSqdbh(wsgpSqdbh);
        sqzb.setSwjgDm(domain.getSlSwjgDm());
        sqzb.setBsdtDjxh(domain.getBsdtDjxh());
        this.ssglSqlMapClientTemplate.insert("insertNsfwWsgpSqzb", sqzb);
        if (!domain.getLgsqList().isEmpty()) {
            for (FpyjlxSaveLgsqDomain fpyjlxSaveLgsqDomain : domain.getLgsqList()) {
                NsfwWsgpFplgsq lgbo = new NsfwWsgpFplgsq();
                BeanUtils.copyProperties((Object)lgbo, (Object)fpyjlxSaveLgsqDomain);
                lgbo.setWsDjhzXh(wsDjhzXh);
                this.ssglSqlMapClientTemplate.insert("insertNsfwWsgpFplgsq", lgbo);
            }
        }
        if (!domain.getYjsqList().isEmpty()) {
            for (FpyjlxSaveYjsqDomain fpyjlxSaveYjsqDomain : domain.getYjsqList()) {
                NsfwWsgpFpyjsq yjbo = new NsfwWsgpFpyjsq();
                BeanUtils.copyProperties((Object)yjbo, (Object)fpyjlxSaveYjsqDomain);
                yjbo.setWsDjhzXh(wsDjhzXh);
                yjbo.setKpje(fpyjlxSaveYjsqDomain.getJe());
                yjbo.setKprqQ(fpyjlxSaveYjsqDomain.getRqQ().replace("-", ""));
                yjbo.setKprqZ(fpyjlxSaveYjsqDomain.getRqZ().replace("-", ""));
                yjbo.setSfscdzxx("Y");
                yjbo.setYjbz("Y");
                this.ssglSqlMapClientTemplate.insert("insertNsfwWsgpFpyjsq", yjbo);
            }
        }
        returnDomain.setCode("00");
        returnDomain.setSssxSlxh(sssx.getSssxSlxh());
        returnDomain.setWjDjhzxh(wsDjhzXh);
        return returnDomain;
    }

    protected void saveSssxSqrxx(SssxSlsqSqrxx sqrxx) throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrbsh", sqrxx.getNsrbsh());
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("xm", HstEncodeUtil.GBK2ISO(sqrxx.getXm()));
        }
        if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("xm", sqrxx.getXm());
        }
        map.put("gddh", sqrxx.getGddh());
        map.put("sjhm", sqrxx.getSjhm());
        List list = this.ssglSqlMapClientTemplate.queryForList("selectSssxSlsqSqrxxByXX", map);
        if (list.isEmpty()) {
            this.ssglSqlMapClientTemplate.insert("insertSssxSlsqSqrxx", sqrxx);
        } else {
            if (StringUtils.isNotBlank((String)sqrxx.getDjxxXh())) {
                sqrxx.setDjxxXh(sqrxx.getDjxxXh());
            } else {
                sqrxx.setDjxxXh(((SssxSlsqSqrxx)list.get(0)).getDjxxXh());
            }
            this.ssglSqlMapClientTemplate.update("updateSssxSlsqSqrxxByKey", sqrxx);
        }
    }

    protected void saveSssxYjxx(SssxSlsqSqrYjxx yjxx) {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrbsh", yjxx.getNsrbsh());
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("sjr", HstEncodeUtil.GBK2ISO(yjxx.getSjr()));
            map.put("dz", HstEncodeUtil.GBK2ISO(yjxx.getDz()));
        }
        if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("sjr", yjxx.getSjr());
            map.put("dz", yjxx.getDz());
        }
        map.put("gddh", yjxx.getGddh());
        map.put("sjhm", yjxx.getSjhm());
        List list = this.ssglSqlMapClientTemplate.queryForList("selectSssxSlsqSqrYjxxBySjr", map);
        if (list.isEmpty()) {
            this.ssglSqlMapClientTemplate.insert("insertSssxSlsqSqrYjxx", yjxx);
        } else {
            if (StringUtils.isNotBlank((String)yjxx.getDjxxXh())) {
                yjxx.setDjxxXh(yjxx.getDjxxXh());
            } else {
                yjxx.setDjxxXh(((SssxSlsqSqrYjxx)list.get(0)).getDjxxXh());
            }
            this.ssglSqlMapClientTemplate.update("updateSssxSlsqSqrYjxxByKey", yjxx);
        }
    }

    public TaxCommonReturnDomain pubGetDmbxx(PubGetDmbxxAppDomain domain) throws Exception {
        PubGetDmbxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("dmbmc", domain.getDmbmc());
        map.put("code", "");
        map.put("mess", "");
        map.put("dataList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("pubGetDmbxxCurr", "dataList", map);
        ArrayList<PubGetDmbxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new PubGetDmbxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpjylxCxNsrSqslxx(FpjylxCxNsrSqslxxAppDomain domain) throws Exception {
        FpjylxCxNsrSqslxxReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.sqlMapClientTemplate.queryForObjectByCurr("fpjylxCxNsrSqslxxCurr", "dataList", map);
        ArrayList<FpjylxCxNsrSqslxxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain = new FpjylxCxNsrSqslxxReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain fpjylxQxsq(FpjylxQxsqAppDomain domain) throws Exception {
        FpjylxQxsqReturnDomain returnDomain = null;
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("sssxSlxh", domain.getSssxSlxh());
        map.put("wsDjhzXh", domain.getWjDjhzxh());
        this.sqlMapClientTemplate.queryForObject("fpjylxQxsqCurr", map);
        returnDomain = new FpjylxQxsqReturnDomain();
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpjylxCxSqslMxxx(FpjylxCxSqslMxxxAppDomain domain) throws Exception {
        FpjylxCxSqslMxxxReturnDomain returnDomain = new FpjylxCxSqslMxxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("sssxSlxh", domain.getSssxSlxh());
        map.put("wsDjhzXh", domain.getWjDjhzxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("fpyjlxcxmxCurr", "dataList", map);
        List mxList = (List)map.get("dataList");
        if ("00".equals((String)map.get("code"))) {
            if (mxList.isEmpty()) {
                returnDomain.setCode("01");
                returnDomain.setMess("\u6ca1\u6709\u76f8\u5173\u4fe1\u606f");
                return returnDomain;
            }
        } else {
            returnDomain.setCode((String)map.get("code"));
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
            return returnDomain;
        }
        BeanUtils.copyProperties((Object)returnDomain, mxList.get(0));
        if (!"3".equals(returnDomain.getWsgpSqlxDm())) {
            map.put("dataList", null);
            this.sqlMapClientTemplate.queryForObjectByCurr("fpyjlxcxmxLgCurr", "dataList", map);
            List lgsqList = (List)map.get("dataList");
            if ("00".equals((String)map.get("code"))) {
                if (!lgsqList.isEmpty()) {
                    returnDomain.setLgsqList(lgsqList);
                }
            } else {
                returnDomain.setCode((String)map.get("code"));
                returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
                return returnDomain;
            }
            map.put("dataList", null);
            this.sqlMapClientTemplate.queryForObjectByCurr("fpyjlxcxmxFfCurr", "dataList", map);
            List fpffList = (List)map.get("dataList");
            if ("00".equals((String)map.get("code"))) {
                if (!fpffList.isEmpty()) {
                    returnDomain.setFpffList(fpffList);
                }
            } else {
                returnDomain.setCode((String)map.get("code"));
                returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
                return returnDomain;
            }
        }
        if (!"2".equals(returnDomain.getWsgpSqlxDm())) {
            map.put("dataList", null);
            this.sqlMapClientTemplate.queryForObjectByCurr("fpyjlxcxmxYjCurr", "dataList", map);
            List yjsqList = (List)map.get("dataList");
            if ("00".equals((String)map.get("code"))) {
                if (!yjsqList.isEmpty()) {
                    returnDomain.setYjsqList(yjsqList);
                }
            } else {
                returnDomain.setCode((String)map.get("code"));
                returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
                return returnDomain;
            }
        }
        returnDomain.setCode("00");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpdkCheckSqzg(FpdkCheckSqzgAppDomain domain) throws Exception {
        FpdkCheckSqzgReturnDomain returnDomain = new FpdkCheckSqzgReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("dkfpsqlxDm", domain.getDkfpsqlxDm());
        this.sqlMapClientTemplate.queryForObjectByCurr("fpdkCheckSqzgCurr", map, "dataList", "yjList");
        List dataList = (List)map.get("dataList");
        if ("00".equals((String)map.get("code"))) {
            if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
                returnDomain.setZgswjgMc(HstToolsUtil.ISO2GBK((String)map.get("zgswjgMc")));
                returnDomain.setFr(HstToolsUtil.ISO2GBK((String)map.get("fr")));
                returnDomain.setCwfzr(HstToolsUtil.ISO2GBK((String)map.get("cwfzr")));
                returnDomain.setXm(HstToolsUtil.ISO2GBK((String)map.get("xm")));
                returnDomain.setXhfdz(HstToolsUtil.ISO2GBK((String)map.get("xhfdz")));
                returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
            } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
                returnDomain.setZgswjgMc((String)map.get("zgswjgMc"));
                returnDomain.setFr((String)map.get("fr"));
                returnDomain.setCwfzr((String)map.get("cwfzr"));
                returnDomain.setXm((String)map.get("xm"));
                returnDomain.setXhfdz((String)map.get("xhfdz"));
                returnDomain.setNsrmc((String)map.get("nsrmc"));
            }
            returnDomain.setLxrList(dataList);
            returnDomain.setNsrsbh(domain.getNsrsbh());
            returnDomain.setZgswjgDm(HstToolsUtil.ISO2GBK((String)map.get("zgswjgDm")));
            returnDomain.setXhfdh(HstToolsUtil.ISO2GBK((String)map.get("xhfdh")));
            returnDomain.setXhfkhyh(HstToolsUtil.ISO2GBK((String)map.get("xhfkhyh")));
            returnDomain.setXhfyhzh(HstToolsUtil.ISO2GBK((String)map.get("xhfyhzh")));
            returnDomain.setSjhm(HstToolsUtil.ISO2GBK((String)map.get("sjhm")));
            returnDomain.setGddh(HstToolsUtil.ISO2GBK((String)map.get("gddh")));
            returnDomain.setDkxybz(HstToolsUtil.ISO2GBK((String)map.get("dkxybz")));
            returnDomain.setYzpsxybz(HstToolsUtil.ISO2GBK((String)map.get("yzpsxybz")));
            returnDomain.setKpxe((String)map.get("kpxe"));
            returnDomain.setXhfyhdm((String)map.get("xhfyhdm"));
            returnDomain.setYjDjxh((String)map.get("yjDjxh"));
            returnDomain.setLxrDjxh((String)map.get("lxrDjxh"));
            returnDomain.setJbdm((String)map.get("jbdm"));
            List yjxxList = (List)map.get("yjList");
            returnDomain.setYjxxList(yjxxList);
            String djxh = (String)map.get("djxh");
            HxzgDjCxNsrSfzxxRequestDomain sfzxxReq = new HxzgDjCxNsrSfzxxRequestDomain();
            sfzxxReq.setBid("GT3.HxzgDjCxNsrSfzxx");
            sfzxxReq.setDjxh(djxh);
            sfzxxReq.setSkssqq(HstDateUtil.getFirstDayMonth());
            sfzxxReq.setSkssqz(HstDateUtil.getLastDayOfMonth(HstDateUtil.getFirstDayMonth()));
            sfzxxReq.setZsxmDm("10101");
            HxzgDjCxNsrSfzxxResponseDomain sfzxxRes = HstWxServiceUtil.sendMess(WebConstants.GT3JK_SJ_URL, sfzxxReq, "GT3.HxzgDjCxNsrSfzxx", HxzgDjCxNsrSfzxxResponseDomain.class);
            if ("00".equals(sfzxxRes.getCode())) {
                for (HxzgDjCxNsrSfzxxDomain zspm : sfzxxRes.getDataList()) {
                    FpdkCheckZspmDomain data = new FpdkCheckZspmDomain();
                    data.setZspmdm(zspm.getZspmDm());
                    data.setZspmmc(zspm.getZspmMc());
                    data.setYgzbz(zspm.getYgzBz());
                    returnDomain.getZspmlist().add(data);
                }
            }
        }
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpdkCxGhfxx(FpdkCxGhfxxAppDomain domain) throws Exception {
        FpdkCxGhfxxReturnDomain returnDomain = new FpdkCxGhfxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("ghnsrsbh", domain.getGhfnsrsbh());
        this.sqlMapClientTemplate.queryForObjectByCurr("fpdkCxGhfxxCurr", "dataList", map);
        List dataList = (List)map.get("dataList");
        if ("00".equals((String)map.get("code")) && !dataList.isEmpty()) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpdkSaveSqxx(FpdkSaveSqxxAppDomain domain) throws Exception {
        FpdkSaveSqxxReturnDomain returnDomain = new FpdkSaveSqxxReturnDomain();
        SssxSlsqSqrxx sqrxx = new SssxSlsqSqrxx();
        sqrxx.setNsrbsh(domain.getNsrsbh());
        sqrxx.setXm(domain.getLxrXm());
        sqrxx.setSjhm(domain.getLxrSjhm());
        sqrxx.setGddh(domain.getLxrGddh());
        sqrxx.setCjrq(HstDateUtil.getCurrentDate());
        sqrxx.setYxbz("Y");
        sqrxx.setDjxxXh(domain.getLxrDjxh());
        this.saveSssxSqrxx(sqrxx);
        String yjdzDjxxXh = "";
        if ("1".equals(domain.getDkfpsqlbDm())) {
            SssxSlsqSqrYjxx yjxx = new SssxSlsqSqrYjxx();
            yjxx.setNsrbsh(domain.getNsrsbh());
            yjxx.setDz(domain.getYjdz());
            yjxx.setGddh(domain.getYjdddh());
            yjxx.setSjhm(domain.getYjsjhm());
            yjxx.setSjr(domain.getYjxm());
            yjxx.setYb(domain.getYjyb());
            yjxx.setYxbz("Y");
            yjxx.setCjrq(HstDateUtil.getCurrentDate());
            yjxx.setDjxxXh(domain.getYjDjxh());
            this.saveSssxYjxx(yjxx);
            yjdzDjxxXh = yjxx.getDjxxXh();
        }
        if (!"2".equals(domain.getDkfpsqlbDm())) {
            domain.setSlSwjgDm("");
            domain.setBsdtDjxh("");
        }
        WsFpDkfpsqLsb bo = new WsFpDkfpsqLsb();
        BeanUtils.copyProperties((Object)bo, (Object)domain);
        String wsDjhzXh = domain.getWsDjhzXh();
        if (StringUtils.isBlank((String)wsDjhzXh)) {
            wsDjhzXh = HstToolsUtil.getSequence(this.ssglSqlMapClientTemplate.getDataSource().getConnection(), "SEQ_WS_DJHZ");
        }
        String dkfpSqdbh = "";
        if ("1".equals(domain.getDkfpsqlbDm())) {
            dkfpSqdbh = "A88" + wsDjhzXh.substring(wsDjhzXh.length() - 12, wsDjhzXh.length());
        } else if ("2".equals(domain.getDkfpsqlbDm())) {
            dkfpSqdbh = "B88" + wsDjhzXh.substring(wsDjhzXh.length() - 12, wsDjhzXh.length());
        } else if ("3".equals(domain.getDkfpsqlbDm())) {
            dkfpSqdbh = "C88" + wsDjhzXh.substring(wsDjhzXh.length() - 12, wsDjhzXh.length());
        } else if ("4".equals(domain.getDkfpsqlbDm())) {
            dkfpSqdbh = "D88" + wsDjhzXh.substring(wsDjhzXh.length() - 12, wsDjhzXh.length());
        }
        bo.setDkfpSqdbh(dkfpSqdbh);
        bo.setWsDjhzXh(wsDjhzXh);
        bo.setLxrDjxh(sqrxx.getDjxxXh());
        bo.setYjdzDjxxXh(yjdzDjxxXh);
        this.sqlMapClientTemplate.insert("insertWsFpDkfpsqLsb", bo);
        for (FpdkSaveSqxxDomain dom : domain.getDataList()) {
            WsFpDkfpsqLsbZb zb = new WsFpDkfpsqLsbZb();
            BeanUtils.copyProperties((Object)zb, (Object)dom);
            zb.setWsDjhzXh(wsDjhzXh);
            this.sqlMapClientTemplate.insert("insertWsFpDkfpsqZbLsb", zb);
        }
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("wsDjhzXh", wsDjhzXh);
        map.put("bcbz", domain.getBcbz());
        this.sqlMapClientTemplate.queryForObject("fpdkSaveSqxxCurr", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        if ("00".equals((String)map.get("code"))) {
            returnDomain.setWjDjhzxh(wsDjhzXh);
            returnDomain.setSssxSlxh((String)map.get("sssxSlxh"));
            returnDomain.setDkfpSqdbh(bo.getDkfpSqdbh());
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpdkCxNsrSqslxx(FpdkCxNsrSqslxxAppDomain domain) throws Exception {
        FpdkCxNsrSqslxxReturnDomain returnDomain = new FpdkCxNsrSqslxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.sqlMapClientTemplate.queryForObjectByCurr("fpdkCxNsrSqslxxCurr", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain fpdkQxsq(FpdkQxsqAppDomain domain) throws Exception {
        FpdkQxsqReturnDomain returnDomain = new FpdkQxsqReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("wsDjhzXh", domain.getWjDjhzxh());
        map.put("sssxSlxh", domain.getSssxSlxh());
        this.sqlMapClientTemplate.queryForObject("fpdkQxsqCurr", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain fpdkCxSqslMxxx(FpdkCxSqslMxxxAppDomain domain) throws Exception {
        FpdkCxSqslMxxxReturnDomain returnDomain = new FpdkCxSqslMxxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("sssxSlxh", domain.getSssxSlxh());
        map.put("wsDjhzXh", domain.getWsDjhzXh());
        this.sqlMapClientTemplate.queryForObjectByCurr("fpdkCxSqslMxxxCurr", "dataList", map);
        List mxList = (List)map.get("dataList");
        if ("00".equals((String)map.get("code"))) {
            if (mxList.isEmpty()) {
                returnDomain.setCode("01");
                returnDomain.setMess("\u6ca1\u6709\u76f8\u5173\u4fe1\u606f");
                return returnDomain;
            }
        } else {
            returnDomain.setCode((String)map.get("code"));
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
            return returnDomain;
        }
        BeanUtils.copyProperties((Object)returnDomain, mxList.get(0));
        map.put("dataList", null);
        this.sqlMapClientTemplate.queryForObjectByCurr("fpdkCxSqslMxxxCurr2", "dataList", map);
        List dataList = (List)map.get("dataList");
        if ("00".equals((String)map.get("code"))) {
            if (!dataList.isEmpty()) {
                returnDomain.setDataList(dataList);
            }
        } else {
            returnDomain.setCode((String)map.get("code"));
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
            return returnDomain;
        }
        returnDomain.setCode("00");
        return returnDomain;
    }

    public QympXhfKpxxTqReturnDomain qympXhfKpxxTq(QympXhfKpxxTqAppDomain domain) throws Exception {
        QympXhfKpxxTqReturnDomain returnDomain = new QympXhfKpxxTqReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("zcuuid", domain.getZcuuid());
        map.put("xhfnsrsbh", domain.getXhfnsrsbh());
        map.put("tqsjhm", domain.getTqsjhm());
        map.put("jhyzm", domain.getJhyzm());
        map.put("bz", domain.getBz());
        domain.setTquuid(EjbJ3Util.getUUID());
        map.put("tquuid", domain.getTquuid());
        this.ssglSqlMapClientTemplate.queryForObject("qympXhfKpxxTqCurr", map);
        returnDomain.setDh(HstToolsUtil.ISO2GBK((String)map.get("dh")));
        returnDomain.setDz(HstToolsUtil.ISO2GBK((String)map.get("dz")));
        returnDomain.setNsrsbh(HstToolsUtil.ISO2GBK((String)map.get("nsrsbh")));
        returnDomain.setKhyh(HstToolsUtil.ISO2GBK((String)map.get("khyh")));
        returnDomain.setYhzh(HstToolsUtil.ISO2GBK((String)map.get("yhzh")));
        returnDomain.setMc(HstToolsUtil.ISO2GBK((String)map.get("mc")));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public QympGhfKprSaveReturnDomain qympGhfKprSave(QympGhfKprSaveAppDomain domain) throws Exception {
        QympGhfKprSaveReturnDomain returnDoamin = new QympGhfKprSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", HstToolsUtil.GBK2ISO(domain.getSwjgDm()));
        map.put("openId", HstToolsUtil.GBK2ISO(domain.getOpenId()));
        map.put("sjhm", HstToolsUtil.GBK2ISO(domain.getSjhm()));
        map.put("sex", HstToolsUtil.GBK2ISO(domain.getSex()));
        map.put("nickName", HstToolsUtil.GBK2ISO(domain.getNickName()));
        map.put("city", HstToolsUtil.GBK2ISO(domain.getCity()));
        map.put("country", HstToolsUtil.GBK2ISO(domain.getCountry()));
        map.put("province", HstToolsUtil.GBK2ISO(domain.getProvince()));
        map.put("subscribeDay", HstToolsUtil.GBK2ISO(domain.getSubscribeDay()));
        map.put("subscribeTime", HstToolsUtil.GBK2ISO(domain.getSubscribeTime()));
        map.put("remark", HstToolsUtil.GBK2ISO(domain.getRemark()));
        map.put("groupid", HstToolsUtil.GBK2ISO(domain.getGroupid()));
        this.ssglSqlMapClientTemplate.queryForObject("qympGhfKprSaveCurr", map);
        returnDoamin.setCode((String)map.get("code"));
        returnDoamin.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDoamin;
    }

    public QympGhfDjxxSaveReturnDomain qympGhfDjxxSave(QympGhfDjxxSaveAppDomain domain) throws Exception {
        QympGhfDjxxSaveReturnDomain returnDoamin = new QympGhfDjxxSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", HstToolsUtil.GBK2ISO(domain.getSwjgDm()));
        map.put("openId", HstToolsUtil.GBK2ISO(domain.getOpenId()));
        map.put("mc", HstToolsUtil.GBK2ISO(domain.getMc()));
        map.put("nsrsbh", HstToolsUtil.GBK2ISO(domain.getNsrsbh()));
        map.put("dz", HstToolsUtil.GBK2ISO(domain.getDz()));
        map.put("dh", HstToolsUtil.GBK2ISO(domain.getDh()));
        map.put("khyh", HstToolsUtil.GBK2ISO(domain.getKhyh()));
        map.put("yhzh", HstToolsUtil.GBK2ISO(domain.getYhzh()));
        map.put("ghfDjxh", HstToolsUtil.GBK2ISO(domain.getGhfDjxh()));
        this.ssglSqlMapClientTemplate.queryForObject("qympGhfDjxxSaveCurr", map);
        returnDoamin.setCode((String)map.get("code"));
        returnDoamin.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDoamin.setGhfDjxh(HstToolsUtil.ISO2GBK((String)map.get("ghfDjxh")));
        return returnDoamin;
    }

    public QympGhfDjxxJhReturnDomain qympGhfDjxxJh(QympGhfDjxxJhAppDomain domain) throws Exception {
        QympGhfDjxxJhReturnDomain returnDoamin = new QympGhfDjxxJhReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", HstToolsUtil.GBK2ISO(domain.getSwjgDm()));
        map.put("openId", HstToolsUtil.GBK2ISO(domain.getOpenId()));
        map.put("sjhm", HstToolsUtil.GBK2ISO(domain.getSjhm()));
        map.put("ghfDjxh", HstToolsUtil.GBK2ISO(domain.getGhfDjxh()));
        map.put("uuid", HstToolsUtil.GBK2ISO(EjbJ3Util.getUUID()));
        this.ssglSqlMapClientTemplate.queryForObject("qympGhfDjxxJhCurr", map);
        returnDoamin.setCode((String)map.get("code"));
        returnDoamin.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDoamin.setJhbz(HstToolsUtil.ISO2GBK((String)map.get("jhbz")));
        returnDoamin.setJhyzm(HstToolsUtil.ISO2GBK((String)map.get("jhyzm")));
        returnDoamin.setTqsjhm(HstToolsUtil.ISO2GBK((String)map.get("tqsjhm")));
        returnDoamin.setYxsj(HstToolsUtil.ISO2GBK((String)map.get("yxsj")));
        return returnDoamin;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghSqdListCx(WghSqdListCxAppDomain domain) throws Exception {
        WghSqdListCxReturnDomain returnDomain = new WghSqdListCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("str", domain.getStr());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("row", "10");
        } else {
            map.put("row", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        map.put("sqrlx", domain.getSqrlx());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6801SqdListCx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghSqdCx(WghSqdCxAppDomain domain) throws Exception {
        WghSqdCxReturnDomain returnDomain = new WghSqdCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("dkfpsq_xh", domain.getDkfpsq_xh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6802SqdCx", map, "sqb", "zblist");
        if ("00".equals((String)map.get("code"))) {
            List sqb = (List)map.get("sqd");
            HstEncodeUtil.conISO2GBK(sqb);
            BeanUtils.copyProperties((Object)returnDomain, sqb.get(0));
            List dataList = (List)map.get("zblist");
            returnDomain.setDataList(dataList);
        }
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghSqdSave(WghSqdSaveAppDomain domain) throws Exception {
        WghSqdSaveReturnDomain returnDomain = new WghSqdSaveReturnDomain();
        String sqdbh = "";
        String dkfpsq_xh = "";
        String bz = "";
        if (StringUtils.isBlank((String)domain.getDkfpsq_xh())) {
            dkfpsq_xh = HstToolsUtil.getSequence(this.sqlMapClientTemplate.getDataSource().getConnection(), "SEQ_DKFPSQ_XH");
            domain.setDkfpsq_xh(dkfpsq_xh);
            bz = "1";
        } else {
            dkfpsq_xh = domain.getDkfpsq_xh();
            bz = "2";
        }
        LsbPtfpFpDkfpsq bo = new LsbPtfpFpDkfpsq();
        BeanUtils.copyProperties((Object)bo, (Object)domain);
        bo.setZfbz("N");
        sqdbh = "W" + dkfpsq_xh.substring(dkfpsq_xh.length() - 10, dkfpsq_xh.length());
        bo.setSqdbh(sqdbh);
        bo.setOpenid(domain.getOpenId());
        String hwlwfwmc = "";
        hwlwfwmc = domain.getDataList().size() > 1 ? String.valueOf(domain.getDataList().get(0).getPm()) + "\u7b49" : domain.getDataList().get(0).getPm();
        bo.setHwlwfwmc(hwlwfwmc);
        bo.setOpenid(domain.getOpenId());
        this.ssglSqlMapClientTemplate.insert("insertLsbPtfpFpDkfpsq", bo);
        LsbPtfpFpDkfpsqZb zb = null;
        int i = 0;
        int size = domain.getDataList().size();
        while (i < size) {
            zb = new LsbPtfpFpDkfpsqZb();
            BeanUtils.copyProperties((Object)zb, (Object)domain.getDataList().get(i));
            zb.setDkfpsqXh(domain.getDkfpsq_xh());
            this.ssglSqlMapClientTemplate.insert("insertLsbPtfpFpDkfpsqZb", zb);
            ++i;
        }
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("dkfpsq_xh", dkfpsq_xh);
        map.put("bz", bz);
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6803SqdSave", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setSqdbh(sqdbh);
        returnDomain.setDkfpsq_xh(dkfpsq_xh);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghSqdZf(WghSqdZfAppDomain domain) throws Exception {
        WghSqdZfReturnDomain returnDomain = new WghSqdZfReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("dkfpsq_xh", domain.getDkfpsq_xh());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6804SqdZf", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghGrxxCx(WghGrxxCxAppDomain domain) throws Exception {
        WghGrxxCxReturnDomain returnDomain = new WghGrxxCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6805GrxxCx", "dataList", map);
        List dataList = (List)map.get("dataList");
        BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghGrxxSave(WghGrxxSaveAppDomain domain) throws Exception {
        WghGrxxSaveReturnDomain returnDomain = new WghGrxxSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("xm", HstEncodeUtil.GBK2ISO(domain.getXm()));
        map.put("sjhm", HstEncodeUtil.GBK2ISO(domain.getSjhm()));
        map.put("sfzhm", HstEncodeUtil.GBK2ISO(domain.getSfzhm()));
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6806GrxxSave", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrBdxxCx(WghNsrBdxxCxAppDomain domain) throws Exception {
        WghNsrBdxxCxReturnDomain returnDomain = new WghNsrBdxxCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("str", domain.getStr());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("row", "10");
        } else {
            map.put("row", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6807NsrbdxxCx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrBdYzm(WghNsrBdYzmAppDomain domain) throws Exception {
        WghNsrBdYzmReturnDomain returnDomain = new WghNsrBdYzmReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6808NsrbdYzm", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setNsrmc(HstToolsUtil.ISO2GBK((String)map.get("nsrmc")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrBd(WghNsrBdAppDomain domain) throws Exception {
        WghNsrBdReturnDomain returnDomain = new WghNsrBdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("yzm", domain.getYzm());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6809Nsrbd", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrBdJc(WghNsrBdJcAppDomain domain) throws Exception {
        WghNsrBdJcReturnDomain returnDomain = new WghNsrBdJcReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("qt_openid", domain.getQt_openid());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6810NsrbdJc", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain WycxNsrwsjdcx(WycxNsrwsjdcxAppDomain domain) throws Exception {
        WycxNsrwsjdcxReturnDomain returnDomain = new WycxNsrwsjdcxReturnDomain();
        Connection conn = null;
        Statement pst = null;
        ResultSet rs = null;
        ArrayList<WycxNsrwsjdcxDomain> dataList = new ArrayList<WycxNsrwsjdcxDomain>();
        try {
            try {
                conn = DBConnectUtil.getConnection(WebConstants.XS_WS_DBURL, WebConstants.XS_WS_USER, WebConstants.XS_WS_PWD, "net.sourceforge.jtds.jdbc.Driver");
            }
            catch (Exception e) {
                returnDomain.setCode("01");
                returnDomain.setMess(e.toString());
                _log.error((Object)e.toString());
                WycxNsrwsjdcxReturnDomain wycxNsrwsjdcxReturnDomain = returnDomain;
                if (rs != null) {
                    rs.close();
                }
                if (pst != null) {
                    pst.close();
                }
                if (conn != null) {
                    conn.close();
                }
                return wycxNsrwsjdcxReturnDomain;
            }
            try {
                conn.setAutoCommit(false);
                StringBuffer sql = new StringBuffer("SELECT WS_ID,NSRSBH,NSRMC,WSXL_MC,SLSJ,WSZT,THBZ FROM V_WSCX ").append("WHERE NSRSBH = ? AND SLSJ >= cast(? as datetime) AND SLSJ <=  cast(? as datetime) ");
                pst = conn.prepareStatement(sql.toString());
                pst.setString(1, domain.getNsrsbh());
                pst.setString(2, domain.getSLSJ_Q());
                pst.setString(3, domain.getSLSJ_Z());
                pst.executeQuery();
                rs = pst.getResultSet();
                while (rs.next()) {
                    WycxNsrwsjdcxDomain dom = new WycxNsrwsjdcxDomain();
                    dom.setWs_id(rs.getString("WS_ID"));
                    dom.setNsrsbh(rs.getString("NSRSBH"));
                    dom.setNsrmc(rs.getString("NSRMC"));
                    dom.setWsxl_mc(rs.getString("WSXL_MC"));
                    dom.setSlsj(rs.getString("SLSJ"));
                    dom.setWszt(rs.getString("WSZT"));
                    dom.setThbz(rs.getString("THBZ"));
                    dataList.add(dom);
                }
                conn.commit();
            }
            catch (Exception e) {
                conn.rollback();
                returnDomain.setCode("01");
                returnDomain.setMess(e.toString());
                _log.error((Object)e.toString());
                WycxNsrwsjdcxReturnDomain wycxNsrwsjdcxReturnDomain = returnDomain;
                return wycxNsrwsjdcxReturnDomain;
            }
        }
        finally {
            if (rs != null) {
                rs.close();
            }
            if (pst != null) {
                pst.close();
            }
            if (conn != null) {
                conn.close();
            }
        }
        returnDomain.setCode("00");
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrBdxxCx2(WghNsrBdxxCx2AppDomain domain) throws Exception {
        WghNsrBdxxCx2ReturnDomain returnDomain = new WghNsrBdxxCx2ReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("str", domain.getStr());
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("row", "10");
        } else {
            map.put("row", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6811NsrbdxxCx2", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrBdGetmd(WghNsrBdGetmdAppDomain domain) throws Exception {
        WghNsrBdGetmdReturnDomain returnDomain = new WghNsrBdGetmdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("xm", domain.getXm());
        map.put("sfzhm", domain.getSfzhm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6812NsrbdGetMd", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain WghNsrBdYzm2(WghNsrBdYzm2AppDomain domain) throws Exception {
        WghNsrBdYzm2ReturnDomain returnDomain = new WghNsrBdYzm2ReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("sjhm", domain.getSjhm());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6813NsrbdYzm2", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain WghNsrBd2(WghNsrBd2AppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("sjhm", domain.getSjhm());
        map.put("yzm", domain.getYzm());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6814Nsrbd2", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain WghNsrBdJc2(WghNsrBdJc2AppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6815Nsrjc2", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain WghNsrBdAddbsy(WghNsrBdAddbsyAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("xm", HstEncodeUtil.GBK2ISO(domain.getXm()));
        map.put("sfzhm", domain.getSfzhm());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6816NsrbdAddBsy", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain WghNsrBdDelbsy(WghNsrBdDelbsyAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("xm", HstEncodeUtil.GBK2ISO(domain.getXm()));
        map.put("sfzhm", domain.getSfzhm());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkWxfw6817NsrbdDelBsy", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain WghNsrBdCxbsy(WghNsrBdCxbsyAppDomain domain) throws Exception {
        WghNsrBdCxbsyReturnDomain returnDomain = new WghNsrBdCxbsyReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6818NsrbdCxBsy", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public List<WghNsrKpxxcxDomain> WghNsrKpxxcx(WghNsrKpxxcxAppDomain domain) throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("NSRSBH", domain.getNsrsbh());
        map.put("GDSLB", "1");
        if ("1".equals(domain.getFpkjlx())) {
            map.put("FPKJLX_DM", "991");
        } else {
            map.put("FPKJLX_DM", "995");
        }
        String dblink = WebConstants.HST_PROP_MAP.get("hst.XSHSDBLINK");
        map.put("dblink", dblink);
        this.xshsSqlMapClientTemplate.queryForObjectByCurr("pXshsWsjk378JkjzKpjese", "dataList", map);
        List dataList = (List)map.get("dataList");
        return dataList;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrKpmxcx(WghNsrKpmxcxAppDomain domain) throws Exception {
        WghNsrKpmxcxReturnDomain returnDomain = new WghNsrKpmxcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("kprqQ", domain.getKprq_q());
        map.put("kprqz", domain.getKprq_z());
        map.put("ghfmc", HstEncodeUtil.GBK2ISO(domain.getGhfmc()));
        if (HstToolsUtil.isNullOrEmpty(domain.getRows())) {
            map.put("rows", "10");
        } else {
            map.put("rows", domain.getRows());
        }
        if (HstToolsUtil.isNullOrEmpty(domain.getPage())) {
            map.put("page", "1");
        } else {
            map.put("page", domain.getPage());
        }
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6827Nsrkpmxcx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrSfzcx(WghNsrSfzcxAppDomain domain) throws Exception {
        WghNsrSfzcxReturnDomain returnDomain = new WghNsrSfzcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getNsrsbh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6828Nsrsfzcx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrDsqccx(WghNsrDsqccxAppDomain domain) throws Exception {
        WghNsrDsqccxReturnDomain returnDomain = new WghNsrDsqccxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getNsrsbh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6829Nsrdsqccx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WghNsrSfxycx(WghNsrSfxycxAppDomain domain) throws Exception {
        WghNsrSfxycxReturnDomain returnDomain = new WghNsrSfxycxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getNsrsbh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6820Nsrsfxycx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public String querySwdjlbDm(String nsrsbh) throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", nsrsbh);
        String dblink = WebConstants.HST_PROP_MAP.get("hst.XSHSDBLINK");
        map.put("dblink", dblink);
        return (String)this.xshsSqlMapClientTemplate.queryForObject("querySwdjbDmBYnsrsbhXshs", map);
    }

    public TaxCommonReturnDomain PubGetNsrDxyzm(PubGetNsrDxyzmAppDomain domain) throws Exception {
        PubGetNsrDxyzmReturnDomain returnDomain = new PubGetNsrDxyzmReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("sfzhm", domain.getSfzhm());
        map.put("sjhm", domain.getSjhm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6114GetBsrdxyzm", map, new String[0]);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain NsrDxyzmYz(NsrDxyzmYzAppDomain domain) throws Exception {
        NsrDxyzmYzReturnDomain returnDomain = new NsrDxyzmYzReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("openId", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("sfzhm", domain.getSfzhm());
        map.put("sjhm", domain.getSjhm());
        map.put("yzm", domain.getYzm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6115NsrdxyzmYz", map, new String[0]);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    public TaxCommonReturnDomain WghNsrJcxxcjCx(WghNsrJcxxcjCxAppDomain domain) throws Exception {
        WghNsrJcxxcjCxReturnDomain returnDomain = new WghNsrJcxxcjCxReturnDomain();
        returnDomain.setCode("00");
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getNsrsbh());
        List dataList = this.xshsSqlMapClientTemplate.queryForList("pWebjk6831FieldList", map);
        WghNsrJcxxcjCxXxDomain gsxx = (WghNsrJcxxcjCxXxDomain)this.xshsSqlMapClientTemplate.queryForObject("pWebjk6831Gsxx", map);
        if (gsxx == null) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u65e0\u7eb3\u7a0e\u4eba\u767b\u8bb0\u4fe1\u606f");
            return returnDomain;
        }
        map.put("ZZJG_DM", gsxx.getZZJG_DM());
        WghNsrJcxxcjCxXxDomain dsxx = (WghNsrJcxxcjCxXxDomain)this.xshsSqlMapClientTemplate.queryForObject("pWebjk6831Dsxx", map);
        if (gsxx == null) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u65e0\u7eb3\u7a0e\u4eba\u767b\u8bb0\u4fe1\u606f");
            return returnDomain;
        }
        if (dsxx == null) {
            dsxx = new WghNsrJcxxcjCxXxDomain();
        }
        map.put("djxh", gsxx.getDJXH());
        String rwxfdjxh = (String)this.xshsSqlMapClientTemplate.queryForObject("pWebjk6831GetRwxfdjxh", map);
        map.put("rwxfdjxh", rwxfdjxh);
        if (StringUtils.isBlank((String)rwxfdjxh)) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u8be5\u4f01\u4e1a\u672a\u4e0b\u53d1\u91c7\u96c6\u4efb\u52a1");
            return returnDomain;
        }
        WghNsrJcxxcjCxNsrtxDomain nsrcj = (WghNsrJcxxcjCxNsrtxDomain)this.xshsSqlMapClientTemplate.queryForObject("pWebjk6831Nsrxxcj", map);
        for (WghNsrJcxxcjCxDomain dom : dataList) {
            String field = dom.getFIELD();
            if (nsrcj == null) {
                nsrcj = new WghNsrJcxxcjCxNsrtxDomain();
            }
            if (HstReflectUtil.containsFiled(nsrcj.getClass(), field).booleanValue()) {
                dom.setNSR_VALUE((String)HstReflectUtil.getFieldValue(nsrcj, field));
                dom.setNSRQYBZ("Y");
            } else {
                dom.setNSRQYBZ("N");
            }
            String dsVal = (String)HstReflectUtil.getFieldValue(dsxx, field);
            String gsVal = (String)HstReflectUtil.getFieldValue(gsxx, field);
            dom.setGS_VALUE(gsVal);
            dom.setGSQYBZ("Y");
            dom.setDS_VALUE(dsVal);
            dom.setDSQYBZ("Y");
            if ("KQCCSZTDJBZ".equals(dom.getFIELD())) {
                if ("Y".equals(gsVal)) {
                    dom.setGS_VALUE("\u662f");
                } else {
                    dom.setGS_VALUE("\u5426");
                }
                if ("Y".equals(dsVal)) {
                    dom.setDS_VALUE("\u662f");
                    continue;
                }
                dom.setDS_VALUE("\u5426");
                continue;
            }
            if (!"QYSDSDJBZ".equals(dom.getFIELD())) continue;
            if ("Y".equals(gsVal)) {
                dom.setGS_VALUE("\u56fd\u7a0e\u767b\u8bb0");
            } else {
                dom.setGS_VALUE("\u56fd\u7a0e\u65e0\u767b\u8bb0");
            }
            if ("Y".equals(dsVal)) {
                dom.setDS_VALUE("\u5730\u7a0e\u767b\u8bb0");
                continue;
            }
            dom.setDS_VALUE("\u5730\u7a0e\u65e0\u767b\u8bb0");
        }
        returnDomain.setDataList(dataList);
        returnDomain.setRWXFDJ_XH(rwxfdjxh);
        return returnDomain;
    }

    public TaxCommonReturnDomain WghNsrJcxxcjSave(WghNsrJcxxcjSaveAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        returnDomain.setCode("00");
        WghNsrJcxxcjCxNsrtxDomain bo = new WghNsrJcxxcjCxNsrtxDomain();
        bo.setRWXFDJ_XH(domain.getRWXFDJ_XH());
        for (WghNsrJcxxcjSaveDomain dom : domain.getDataList()) {
            HstReflectUtil.setFieldValue(bo, dom.getFIELD(), String.class, dom.getNSR_VALUE());
        }
        if (StringUtils.isBlank((String)bo.getNSRSBH())) {
            bo.setNSRSBH(domain.getNsrsbh());
        }
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("rwxfdjxh", domain.getRWXFDJ_XH());
        if (StringUtils.isBlank((String)domain.getSavebz())) {
            map.put("savebz", "2");
        } else {
            map.put("savebz", domain.getSavebz());
        }
        WghNsrJcxxcjCxNsrtxDomain nsrcj = (WghNsrJcxxcjCxNsrtxDomain)this.xshsSqlMapClientTemplate.queryForObject("pWebjk6831Nsrxxcj", map);
        if (nsrcj == null) {
            this.xshsSqlMapClientTemplate.insert("insertWghXxbdNsrxxNsrcj", bo);
        } else {
            BeanUtils.copyProperties((Object)nsrcj, (Object)bo);
            this.xshsSqlMapClientTemplate.update("updateWghXxbdNsrxxNsrcj", nsrcj);
        }
        map.put("cjfs", "3");
        this.xshsSqlMapClientTemplate.update("updateWghXxbdRwxfSaveBz", map);
        returnDomain.setCode("00");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain queryQyGlxxBySfzhm(FpdkQueryQyGlxxBySfzhmAppDomain domain) throws Exception {
        FpdkQueryQyGlxxBySfzhmReturnDomain returnDomain = new FpdkQueryQyGlxxBySfzhmReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("sfzhm", domain.getSfzhm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6901QyglxxBysSfzh", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setSmsmcj((String)map.get("sfsmcj"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain PubGetSmzDxyzm(PubGetSmzDxyzmAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("xm", HstEncodeUtil.GBK2ISO(domain.getXm()));
        map.put("sfzhm", domain.getSfzhm());
        map.put("sjhm", domain.getSjhm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWbjkWxfw6116PubSmzDxyzm", map, new String[0]);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain BsyDxSmyz(BsyDxSmyzAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("xm", HstEncodeUtil.GBK2ISO(domain.getXm()));
        map.put("sfzhm", domain.getSfzhm());
        map.put("sjhm", domain.getSjhm());
        map.put("yzm", domain.getYzm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWbjkWxfw6117BsyDxsmyz", map, new String[0]);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WdsxGetQhhm(WdsxGetQhhmAppDomain domain) throws Exception {
        WdsxGetQhhmReturnDomain returnDomain = new WdsxGetQhhmReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("str", domain.getStr());
        map.put("rows", domain.getRows());
        map.put("page", domain.getPage());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWbjkWxfw6232WdsxGetQhhm", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WdsxQhhmPj(WdsxQhhmPjAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("bsdt_djxh", domain.getBsdt_djxh());
        map.put("qhhm", domain.getQhhm());
        map.put("rq", domain.getRq());
        map.put("pjdm", domain.getPjdm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWbjkWxfw6233WdsxQhhmPj", map, new String[0]);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain queryDkfpSfzxx(FpdkQueryDkfpSfzxxAppDomain domain) throws Exception {
        FpdkQueryDkfpSfzxxReturnDomain returnDomain = new FpdkQueryDkfpSfzxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("wsDjhzXh", domain.getWsDjhzXh());
        map.put("sqdbh", domain.getDkfpSqdbh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkArm11108cxdsdzsfzxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        for (FpdkQueryDkfpSfzxxDomain dom : dataList) {
            if (!StringUtils.isNotBlank((String)dom.getZspm_dm())) continue;
            dom.setGdslb("2");
            returnDomain.getDataList().add(dom);
        }
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WdsxSaveHfxx(WdsxSaveHfxxAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("tzggxh", domain.getTzggXh());
        map.put("nrlb", domain.getNrlb());
        map.put("hfsj", domain.getHfsj());
        map.put("hfnr", HstEncodeUtil.GBK2ISO(domain.getHfnr()));
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWbjkWxfw6235SaveHfxx", map, new String[0]);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WdsxGlqymd(WdsxGlqymdAppDomain domain) throws Exception {
        WdsxGlqymdReturnDomain returnDomain = new WdsxGlqymdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("str", domain.getStr());
        map.put("rows", domain.getRows());
        map.put("page", domain.getPage());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6234WdsxGlqymd", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain WdsxNsrdjxxCx(WdsxNsrdjxxCxAppDomain domain) throws Exception {
        WdsxNsrdjxxCxReturnDomain returnDomain = new WdsxNsrdjxxCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6236NsrDjxxcx", "dataList", map);
        List dataList = (List)map.get("dataList");
        if ("00".equals((String)map.get("code"))) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain GlyGetBssx(GlyGetBssxAppDomain domain) throws Exception {
        WdsxGlqymdReturnDomain returnDomain = new WdsxGlqymdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("cxswjgdm", domain.getCxswjgdm());
        map.put("lb", domain.getLb());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6516GlyGteBssx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain GlyCxDhhm(GlyCxDhhmAppDomain domain) throws Exception {
        WdsxGlqymdReturnDomain returnDomain = new WdsxGlqymdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("dhhm", domain.getDhhm());
        map.put("cxswjgdm", domain.getCxswjgdm());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6517GlyCxdhhm", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain GlyCxTj(GlyCxTjAppDomain domain) throws Exception {
        WdsxGlqymdReturnDomain returnDomain = new WdsxGlqymdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("cxswjgdm", domain.getCxswjgdm());
        map.put("xbqybz", domain.getXbqybz());
        map.put("jdxzdm", domain.getJdxzdm());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("nsrmc", HstEncodeUtil.GBK2ISO(domain.getNsrmc()));
        map.put("xxdz", HstEncodeUtil.GBK2ISO(domain.getXxdz()));
        map.put("bssxwh_xh", domain.getBssxwh_xh());
        map.put("djxh", domain.getDjxh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw6518GlyCxTj", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain PubGetNsr(PubGetNsrAppDomain domain) throws Exception {
        PubGetNsrReturnDomain returnDomain = new PubGetNsrReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("nsrsbh", domain.getNsrsbh());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkwxfw6119PubGetNsr", "dataList", map);
        List dataList = (List)map.get("dataList");
        if (dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain PubGetJdxz(PubGetJdxzAppDomain domain) throws Exception {
        PubGetJdxzReturnDomain returnDomain = new PubGetJdxzReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkwxfw6118PubGetJdxz", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain QytjTjrw(QytjTjrwAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("sssqq", domain.getSssqq());
        map.put("sssqz", domain.getSssqz());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkwxfw6407QytjTjrw", map);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain QytjDelrw(QytjDelrwAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("uuid", domain.getTjrw_uuid());
        this.ssglSqlMapClientTemplate.queryForObject("pWebjkwxfw6408QytjDelrw", map);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain QytjCxrw(QytjCxrwAppDomain domain) throws Exception {
        QytjCxrwReturnDomain returnDomain = new QytjCxrwReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("row", domain.getRows());
        map.put("page", domain.getPage());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkwxfw6409QytjCxrw", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain QytjCxtjjg(QytjCxtjjgAppDomain domain) throws Exception {
        QytjCxtjjgReturnDomain returnDomain = new QytjCxtjjgReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("uuid", domain.getTjrw_uuid());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWebjkwxfw6410QytjCxrw", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
            returnDomain.setTjjgms(HstToolsUtil.ISO2GBK((String)map.get("tjjgms")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
            returnDomain.setTjjgms((String)map.get("tjjgms"));
        }
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain SqhdGetMess(SqhdGetMessAppDomain domain) throws Exception {
        SqhdGetMessReturnDomain returnDomain = new SqhdGetMessReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.ssglSqlMapClientTemplate.queryForObjectByCurr("pWbjkWxfw6237SqhdGetMess", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain SqhdSendMess(SqhdSendMessAppDomain domain) throws Exception {
        SqhdSendMessReturnDomain returnDomain = new SqhdSendMessReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("swry_dm", domain.getSwry_dm());
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("fsnr", HstEncodeUtil.GBK2ISO(domain.getFsnr()));
        } else {
            map.put("fsnr", domain.getFsnr());
        }
        map.put("xxlx", domain.getXxlx());
        this.ssglSqlMapClientTemplate.queryForObject("pWbjkWxfw6238SqhdSendMess", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setXxdj_xh((String)map.get("xxdj_xh"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain PubSaveSmrzxx(PubSaveSmrzxxAppDomain domain) throws Exception {
        SmzBsyHtyzjl bo = new SmzBsyHtyzjl();
        BeanUtils.copyProperties((Object)bo, (Object)domain);
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        bo.setDatabaseUsername(databaseUsername);
        bo.setXtbz("1");
        if (StringUtils.isNotBlank((String)domain.getSfzpic())) {
            bo.setSfzpic(domain.getSfzpic().replaceAll("\r\n", "").replaceAll("\\s", "%2B").replaceAll("\\+", "%2B"));
        }
        if (StringUtils.isNotBlank((String)domain.getSfzpic2())) {
            bo.setSfzpic2(domain.getSfzpic2().replaceAll("\r\n", "").replaceAll("\\s", "%2B").replaceAll("\\+", "%2B"));
        }
        if (StringUtils.isNotBlank((String)domain.getSpbm())) {
            bo.setSpbm(domain.getSpbm().replaceAll("\r\n", "").replaceAll("\\s", "%2B").replaceAll("\\+", "%2B"));
        }
        if (StringUtils.isNotBlank((String)domain.getRxpic())) {
            bo.setRxpic(domain.getRxpic().replaceAll("\r\n", "").replaceAll("\\s", "%2B").replaceAll("\\+", "%2B"));
        }
        this.ssglSqlMapClientTemplate.insert("insertSmzBsyHtyzjl", bo);
        String uuid = bo.getYzjluuid();
        SqhdSendMessReturnDomain returnDomain = new SqhdSendMessReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("uuid", uuid);
        map.put("databaseUsername", databaseUsername);
        this.ssglSqlMapClientTemplate.queryForObject("pWebjk6120PubSaveSmzrzxx", map);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Ssgl")
    public TaxCommonReturnDomain PubSaveSmrzxx2(PubSaveSmrzxx2AppDomain domain) throws Exception {
        FwhZzfdWxsmrz bo = new FwhZzfdWxsmrz();
        BeanUtils.copyProperties((Object)bo, (Object)domain);
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        bo.setDatabaseUsername(databaseUsername);
        bo.setSmrz_uuid(domain.getSmrz_uuid());
        if (StringUtils.isNotBlank((String)domain.getSfzpic())) {
            bo.setSfzpic(domain.getSfzpic().replaceAll("\r\n", "").replaceAll("\\s", "%2B").replaceAll("\\+", "%2B"));
        }
        if (StringUtils.isNotBlank((String)domain.getSfzpic2())) {
            bo.setSfzpic2(domain.getSfzpic2().replaceAll("\r\n", "").replaceAll("\\s", "%2B").replaceAll("\\+", "%2B"));
        }
        if (StringUtils.isNotBlank((String)domain.getRxpic())) {
            bo.setRxpic(domain.getRxpic().replaceAll("\r\n", "").replaceAll("\\s", "%2B").replaceAll("\\+", "%2B"));
        }
        this.ssglSqlMapClientTemplate.update("udpateFwhZzfdWxsmrz", bo);
        SqhdSendMessReturnDomain returnDomain = new SqhdSendMessReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgDm());
        map.put("openid", domain.getOpenId());
        map.put("uuid", domain.getSmrz_uuid());
        map.put("databaseUsername", databaseUsername);
        this.ssglSqlMapClientTemplate.queryForObject("pWebjk6121PubSaveSmzrzxx2", map);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain WghJkxxSave(WghJkxxSaveAppDomain domain) throws Exception {
        WghJkxxSaveReturnDomain returnDomain = new WghJkxxSaveReturnDomain();
        String gsjkxh = "";
        String dsjkxh = "";
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("nsrsbh", domain.getSfzhm());
        this.xshsSqlMapClientTemplate.queryForObject("pWebjkWxfw6833WghJkxxSaveJy", map);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        if (!"00".equals(returnDomain.getCode())) {
            return returnDomain;
        }
        for (WghJkxxSaveDomain dom : domain.getDataList()) {
            PtfpSpJkxx bo = new PtfpSpJkxx();
            bo.setSwjg_dm(domain.getSwjg_dm());
            bo.setDjxh(domain.getDjxh());
            bo.setNsrsbh(domain.getNsrsbh());
            bo.setZjlx(domain.getZjlx());
            bo.setSfzhm(domain.getSfzhm());
            bo.setXm(domain.getXm());
            bo.setSkrdm(domain.getSkrdm());
            bo.setSkrmc(domain.getSkrmc());
            bo.setSbbs(domain.getSbbs());
            bo.setGdslb(dom.getGdslb());
            bo.setSehj(dom.getSehj());
            bo.setJkfs(dom.getJkfs());
            bo.setJkpzxh(dom.getJkpzxh());
            bo.setJkrq(dom.getJkrq());
            bo.setZfbz("0");
            bo.setHkbz("N");
            this.xshsSqlMapClientTemplate.insert("insertPtfpSpJkxx", bo);
            if ("1".equals(dom.getGdslb())) {
                gsjkxh = bo.getJkxh();
            } else if ("2".equals(dom.getGdslb())) {
                dsjkxh = bo.getJkxh();
            }
            if (dom.getSubList() == null || dom.getSubList().size() == 0) {
                returnDomain.setCode("01");
                returnDomain.setMess("\u672a\u4f20\u7f34\u6b3e\u660e\u7ec6");
                return returnDomain;
            }
            for (WghJkxxSaveSubDomain sub : dom.getSubList()) {
                PtfpSpJkxxMx zb = new PtfpSpJkxxMx();
                zb.setJkxh(bo.getJkxh());
                zb.setSe(sub.getSe());
                zb.setSli(sub.getSli());
                zb.setZspm_dm(sub.getZspm_dm());
                zb.setZsxm_dm(sub.getZsxm_dm());
                this.xshsSqlMapClientTemplate.insert("insertPtfpSpJkxxMx", zb);
            }
        }
        map.put("nsrsbh", domain.getSfzhm());
        map.put("dsjkxh", dsjkxh);
        map.put("gsjkxh", gsjkxh);
        this.xshsSqlMapClientTemplate.queryForObject("pWebjkWxfw6833WghJkxxSaveHxcl", map);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        if (!"00".equals(returnDomain.getCode())) {
            return returnDomain;
        }
        returnDomain.setCode("00");
        returnDomain.setDsjkxh(dsjkxh);
        returnDomain.setGsjkxh(gsjkxh);
        return returnDomain;
    }

    public TaxCommonReturnDomain WghJkxxZf(WghJkxxZfAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjg_dm", domain.getSwjg_dm());
        map.put("gsjkxh", domain.getGsjkxh());
        map.put("dsjkxh", domain.getDsjkxh());
        map.put("zfrdm", domain.getZfrdm());
        map.put("zfsj", domain.getZfsj());
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            map.put("zfrmc", HstEncodeUtil.GBK2ISO(domain.getZfrmc()));
        } else {
            map.put("zfrmc", domain.getZfrmc());
        }
        this.xshsSqlMapClientTemplate.queryForObject("pWebjkWxfw6834WghJkxxZf", map);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain YyfwBsypj(YyfwBsypjAppDomain domain) throws Exception {
        YyfwBsypjReturnDomain returnDomain = new YyfwBsypjReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("yyfwXh", domain.getYyfwXh());
        map.put("bsypj_zynl", domain.getBsypj_zynl());
        map.put("bsypj_fwtd", domain.getBsypj_fwtd());
        map.put("bsypj_pjnr", HstEncodeUtil.GBK2ISO(domain.getBsypj_pjnr()));
        this.sqlMapClientTemplate.queryForObject("pWebjk6519wxfwBsypj", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain XxcjGetNsrmd(XxcjGetNsrmdAppDomain domain) throws Exception {
        XxcjGetNsrmdReturnDomain returnDomain = new XxcjGetNsrmdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        this.sqlMapClientTemplate.queryForObjectByCurr("XxcjGetNsrmd", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode((String)map.get("code"));
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain XxcjGetNsrZlscqk(XxcjGetNsrZlscqkAppDomain domain) throws Exception {
        XxcjGetNsrZlscqkReturnDomain returnDomain = new XxcjGetNsrZlscqkReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("rw_uuid", domain.getRw_uuid());
        this.sqlMapClientTemplate.queryForObjectByCurr("XxcjGetNsrZlscqk", map, "datRtn", "dataList");
        List dataList = (List)map.get("dataList");
        List datRtn = (List)map.get("datRtn");
        String code = (String)map.get("code");
        if ("00".equals(code) && datRtn.size() > 0) {
            returnDomain = (XxcjGetNsrZlscqkReturnDomain)datRtn.get(0);
            returnDomain.setCode(code);
            returnDomain.setDataList(dataList);
        }
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain XxcjGetNsrZlyscxx(XxcjGetNsrZlyscxxAppDomain domain) throws Exception {
        XxcjGetNsrZlyscxxReturnDomain returnDomain = new XxcjGetNsrZlyscxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("rw_uuid", domain.getRw_uuid());
        map.put("bdjzl_xh", domain.getBdjzl_xh());
        this.sqlMapClientTemplate.queryForObjectByCurr("XxcjGetNsrZlyscxx", map, "datRtn", "dataList");
        List dataList = (List)map.get("dataList");
        List datRtn = (List)map.get("datRtn");
        String code = (String)map.get("code");
        if ("00".equals(code) && datRtn.size() > 0) {
            returnDomain = (XxcjGetNsrZlyscxxReturnDomain)datRtn.get(0);
            returnDomain.setCode(code);
            returnDomain.setDataList(dataList);
        }
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain XxcjSaveSczl(XxcjSaveSczlAppDomain domain) throws Exception {
        XxcjSaveSczlReturnDomain returnDomain = new XxcjSaveSczlReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("rw_uuid", domain.getRw_uuid());
        map.put("bdjzl_xh", domain.getBdjzl_xh());
        if (StringUtils.isBlank((String)domain.getZlpic_nr())) {
            returnDomain.setCode("01");
            returnDomain.setMess("\u8bf7\u4e0a\u4f20\u8d44\u6599");
            return returnDomain;
        }
        domain.setZlpic_nr(domain.getZlpic_nr().replaceAll("\r\n", "").replaceAll("\\s", "%2B").replaceAll("\\+", "%2B"));
        HstEncodeUtil.decodeURL(domain);
        map.put("zlpic_nr", domain.getZlpic_nr());
        this.sqlMapClientTemplate.queryForObjectByCurr("XxcjSaveSczl", map, "dataList");
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        if ("00".equals(code) && dataList.size() > 0) {
            returnDomain = (XxcjSaveSczlReturnDomain)dataList.get(0);
            returnDomain.setCode(code);
        }
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain XxcjDelSczl(XxcjDelSczlAppDomain domain) throws Exception {
        XxcjDelSczlReturnDomain returnDomain = new XxcjDelSczlReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("rw_uuid", domain.getRw_uuid());
        map.put("bdjzl_xh", domain.getBdjzl_xh());
        map.put("zl_uuid", domain.getZl_uuid());
        this.sqlMapClientTemplate.queryForObject("XxcjDelSczl", map);
        String code = (String)map.get("code");
        returnDomain.setCode(code);
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain XxcjSczlTjsh(XxcjSczlTjshAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgDm", domain.getSwjgDm());
        map.put("openId", domain.getOpenId());
        map.put("djxh", domain.getDjxh());
        map.put("rw_uuid", domain.getRw_uuid());
        this.sqlMapClientTemplate.queryForObject("XxcjSczlTjsh", map);
        String code = (String)map.get("code");
        returnDomain.setCode(code);
        if ("ISO".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstToolsUtil.ISO2GBK((String)map.get("mess")));
        } else if ("GBK".equalsIgnoreCase(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess((String)map.get("mess"));
        }
        return returnDomain;
    }
}
