/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.google.gson.Gson
 *  org.apache.commons.beanutils.BeanUtils
 *  org.apache.commons.lang.StringUtils
 *  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.google.gson.Gson;
import com.hst.common.bo.FwhYyfwYysjfb;
import com.hst.common.bo.LsbZhdjTwxxSave;
import com.hst.common.bo.LsbZhdjWjcj;
import com.hst.common.bo.QyhWddwHd;
import com.hst.common.bo.QyhWddwHdBm;
import com.hst.common.bo.QyhWddwHdFj;
import com.hst.common.bo.QyhWddwHdGr;
import com.hst.common.bo.QyhWddwTz;
import com.hst.common.bo.QyhWddwTzBm;
import com.hst.common.bo.QyhWddwTzFj;
import com.hst.common.bo.QyhWddwTzGr;
import com.hst.common.bo.QyhWdsxFx;
import com.hst.common.bo.QyhWdsxFxBm;
import com.hst.common.bo.QyhWdsxFxFj;
import com.hst.common.bo.QyhWdsxFxGr;
import com.hst.common.bo.QyhZhdjTwxxLog;
import com.hst.common.bo.QyhZhdjTwxxLogYwbw;
import com.hst.common.domain.TaxCommonReturnDomain;
import com.hst.common.util.DesUtils;
import com.hst.framework.common.HstSqlMapClientTemplate;
import com.hst.framework.common.HstZhdjSqlMapClientTemplate;
import com.hst.framework.constants.WebConstants;
import com.hst.framework.dao.BaseDao;
import com.hst.framework.util.HstDateUtil;
import com.hst.framework.util.HstEncodeUtil;
import com.hst.framework.util.HstToolsUtil;
import com.hst.taxService.domain.wxqyh.GrzxFxDeleteAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxDeleteReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxListAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxListDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxListReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxSaveAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxSaveBmDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxSaveCzyDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxSaveFjDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxfjcxAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxFxfjcxReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxGrszCxAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxGrszCxDomain;
import com.hst.taxService.domain.wxqyh.GrzxGrszCxReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxGrszSaveAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxGrszSaveDomain;
import com.hst.taxService.domain.wxqyh.GrzxGrszSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxKqNjxjcxAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxKqNjxjcxReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxKqYdkqcxAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxKqYdkqcxReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxKqYdkqmxcxAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxKqYdkqmxcxReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxRcListAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxRcListReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxRcSaveAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxRcSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxRzCsrzAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxRzCsrzReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxRzListAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxRzListReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxRzSaveAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxRzSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxTzDeleteAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxTzDeleteReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxWdhyBgchryAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxWdhyBgchryReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxWdhyCxAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxWdhyCxReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxXxHfAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxXxHfReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxXxListAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxXxListReturnDomain;
import com.hst.taxService.domain.wxqyh.GrzxXxMxAppDomain;
import com.hst.taxService.domain.wxqyh.GrzxXxMxReturnDomain;
import com.hst.taxService.domain.wxqyh.PubGetBmqzRyxxAppDomain;
import com.hst.taxService.domain.wxqyh.PubGetBmqzRyxxDomain;
import com.hst.taxService.domain.wxqyh.PubGetBmqzRyxxReturnDomain;
import com.hst.taxService.domain.wxqyh.PubGetBmqzxxCxDomain;
import com.hst.taxService.domain.wxqyh.PubGetBmqzxxDomain;
import com.hst.taxService.domain.wxqyh.PubGetClxxAppDomain;
import com.hst.taxService.domain.wxqyh.PubGetClxxReturnDomain;
import com.hst.taxService.domain.wxqyh.PubGetDmbAppDomain;
import com.hst.taxService.domain.wxqyh.PubGetDmbReturnDomain;
import com.hst.taxService.domain.wxqyh.PubGetHysxxAppDomain;
import com.hst.taxService.domain.wxqyh.PubGetHysxxReturnDomain;
import com.hst.taxService.domain.wxqyh.PubGetNsrjyxxAppDomain;
import com.hst.taxService.domain.wxqyh.PubGetNsrjyxxReturnDomain;
import com.hst.taxService.domain.wxqyh.PubGetSwryListAppDomain;
import com.hst.taxService.domain.wxqyh.PubGetSwryListReturnDomain;
import com.hst.taxService.domain.wxqyh.PubGetSwryxxAppDomain;
import com.hst.taxService.domain.wxqyh.PubGetSwryxxReturnDomain;
import com.hst.taxService.domain.wxqyh.PubSaveSwryAppDomain;
import com.hst.taxService.domain.wxqyh.PubSaveSwryReturnDomain;
import com.hst.taxService.domain.wxqyh.QdqtSwryDqztAppDomain;
import com.hst.taxService.domain.wxqyh.QdqtSwryDqztReturnDomain;
import com.hst.taxService.domain.wxqyh.QdqtSwryQdqtAppDomain;
import com.hst.taxService.domain.wxqyh.QdqtSwryQdqtLogAppDomain;
import com.hst.taxService.domain.wxqyh.QdqtSwryQdqtLogReturnDomain;
import com.hst.taxService.domain.wxqyh.QdqtSwryQdqtReturnDomain;
import com.hst.taxService.domain.wxqyh.QdqtSwrySgqxAppDomain;
import com.hst.taxService.domain.wxqyh.QdqtSwrySgqxReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrblywxxAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrblywxxReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrdjxxAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrdjxxReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrflxxAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrflxxMdAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrflxxMdReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrflxxReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrfxyjxxAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrfxyjxxReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrlxrxxAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrlxrxxReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrmdcxAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrmdcxReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrxxfsAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrxxfsReturnDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrxxmxAppDomain;
import com.hst.taxService.domain.wxqyh.SqhdNsrxxmxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxHyssqCxmxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxHyssqCxmxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxHyssqQxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxHyssqQxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxHyssqSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxHyssqSaveChrDomain;
import com.hst.taxService.domain.wxqyh.WbsxHyssqSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxHysysqxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxHysysqxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxJbsqCxmxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxJbsqCxmxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxJbsqQxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxJbsqQxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxJbsqSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxJbsqSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxJbysqxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxJbysqxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxQjsqCxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxQjsqCxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxQjsqSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxQjsqSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxQjsqmxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxQjsqmxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxQxjQxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxQxjQxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxQxjysqxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxQxjysqxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxSmhcsqCxmxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxSmhcsqCxmxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxSmhcsqQxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxSmhcsqQxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxSmhcsqSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxSmhcsqSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxSmhcysqxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxSmhcysqxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzFjcxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzFjcxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzSaveBmDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzSaveCzyDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzSaveFjDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzcxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzcxDomain;
import com.hst.taxService.domain.wxqyh.WbsxTzcxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxWcsqCxmxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxWcsqCxmxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxWcsqQxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxWcsqSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxWcsqSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxWcysqxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxWcysqxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxXjsqSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxXjsqSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxXjsqmxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxXjsqmxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcsqCxmxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcsqCxmxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcsqQxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcsqQxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcsqSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcsqSavePjAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcsqSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcsqSaveYcrDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcysqxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYcysqxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwCxLsxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwCxLsxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwSwrypjAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwSwrypjReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwThyyAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwThyyReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwYynsrAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwYynsrReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwYyyxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwYyyxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwapSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwapSaveDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwapSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwapxxAppDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwapxxDomain;
import com.hst.taxService.domain.wxqyh.WbsxYyfwapxxReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwClListAppDomain;
import com.hst.taxService.domain.wxqyh.WddwClListDomain;
import com.hst.taxService.domain.wxqyh.WddwClListReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwFxDzSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WddwFxDzSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwFxListAppDomain;
import com.hst.taxService.domain.wxqyh.WddwFxListDomain;
import com.hst.taxService.domain.wxqyh.WddwFxListReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwFxPlSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WddwFxPlSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdBmDeleteAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdBmDeleteReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdBmSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdBmSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdDeleteAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdDeleteReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdDzSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdDzSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdFbSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdFbSaveBmDomain;
import com.hst.taxService.domain.wxqyh.WddwHdFbSaveCzyDomain;
import com.hst.taxService.domain.wxqyh.WddwHdFbSaveFjDomain;
import com.hst.taxService.domain.wxqyh.WddwHdFbSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdListAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdListDomain;
import com.hst.taxService.domain.wxqyh.WddwHdListReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdPlSaveAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdPlSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdcyrycxAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdcyrycxReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHdfjcxAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHdfjcxReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwHysListAppDomain;
import com.hst.taxService.domain.wxqyh.WddwHysListDomain;
import com.hst.taxService.domain.wxqyh.WddwHysListReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwQxListAppDomain;
import com.hst.taxService.domain.wxqyh.WddwQxListReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwTxlListAppDomain;
import com.hst.taxService.domain.wxqyh.WddwTxlListReturnDomain;
import com.hst.taxService.domain.wxqyh.WddwTzListAppDomain;
import com.hst.taxService.domain.wxqyh.WddwTzListReturnDomain;
import com.hst.taxService.domain.wxqyh.WzhhyFjChkAppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyFjLockAppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHylistCx2AppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHylistCx2ReturnDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHylistCxAppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHylistCxReturnDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHyloginAppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHyloginReturnDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHymcCx2AppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHymcCx2ReturnDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHymcCxAppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyHymcCxReturnDomain;
import com.hst.taxService.domain.wxqyh.WzhhyPzfjclAppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyPzfjclReturnDomain;
import com.hst.taxService.domain.wxqyh.WzhhyYtJhgbAppDomain;
import com.hst.taxService.domain.wxqyh.WzhhyYtJhgbReturnDomain;
import com.hst.taxService.domain.wxqyh.YbsxClapCxAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxClapSaveAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxClapSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.YbsxDbrwCxAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxDbrwCxReturnDomain;
import com.hst.taxService.domain.wxqyh.YbsxDbrwWcSaveAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxDpsxCxAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxDpsxCxReturnDomain;
import com.hst.taxService.domain.wxqyh.YbsxDpsxSptjAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxDpsxSpxxCxAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxDpsxSpxxCxReturnDomain;
import com.hst.taxService.domain.wxqyh.YbsxGztxCxAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxGztxCxReturnDomain;
import com.hst.taxService.domain.wxqyh.YbsxGztxSaveCkbzAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxGztxSaveCkbzDomain;
import com.hst.taxService.domain.wxqyh.YbsxGztxSaveCkbzReturnDomain;
import com.hst.taxService.domain.wxqyh.YbsxHyChrDomain;
import com.hst.taxService.domain.wxqyh.YbsxHyDomain;
import com.hst.taxService.domain.wxqyh.YbsxHyfbBgchryAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxHyfbCwryDomain;
import com.hst.taxService.domain.wxqyh.YbsxHyfbCxAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxHyfbCxDomain;
import com.hst.taxService.domain.wxqyh.YbsxHyfbCxReturnDomain;
import com.hst.taxService.domain.wxqyh.YbsxHyfbSchyjyAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxSltjCxAppDomain;
import com.hst.taxService.domain.wxqyh.YbsxSltjCxReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjGrGetDyjfAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjGrGetDyjfReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjGrGetGlqxAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjGrGetGlqxReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjGrGetJbxxAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjGrGetJbxxReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjGrSaveGlqxAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjGrSaveGlqxReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjHdGetHdlxAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjHdGetHdlxReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjMLGetListAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjMLGetListReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjMLUpdateAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTpGetMxAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTpGetMxDataDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTpGetMxDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTpGetMxReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTpGetTjAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTpGetTjReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTpSaveAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTpSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxDoSaveAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxDoSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetHfAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetHfDataDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetHfDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetHfReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetHfSubDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetListAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetListReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetMxAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetMxReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetRyAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetRyReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetTjAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxGetTjReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxSaveAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxSaveHfAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxSaveHfReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjTwxxSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjGetMxAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjGetMxDataDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjGetMxDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjGetMxReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjGetMxSubDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjSaveAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjSaveDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjSaveReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjWjSaveSubDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZxcsGetCstmAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZxcsGetCstmDataDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZxcsGetCstmDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZxcsGetCstmReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZxcsGetTjAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZxcsGetTjReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZxcsSaveCstmAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZxcsSaveCstmReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZzjgGetDymdAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZzjgGetDymdReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZzjgGetDzbAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZzjgGetDzbReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZzjgGetJjgAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZzjgGetJjgReturnDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZzjgGetQzAppDomain;
import com.hst.taxService.domain.wxqyh.ZhdjZzjgGetQzReturnDomain;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang.StringUtils;
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 TaxWxqyhAppDaoImp
implements BaseDao {
    @Autowired
    private HstSqlMapClientTemplate sqlMapClientTemplate;
    @Autowired
    private HstZhdjSqlMapClientTemplate zhdjSqlMapClientTemplate;

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain PubGetDmb(PubGetDmbAppDomain domain) throws Exception {
        PubGetDmbReturnDomain returnDomain = new PubGetDmbReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("tablename", domain.getTablename());
        this.sqlMapClientTemplate.queryForObjectByCurr("pwWebjkWxfw10101Dmb", "dataList", map);
        List dataList = (List)map.get("dataList");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    public TaxCommonReturnDomain PubGetSwryxx(PubGetSwryxxAppDomain domain) throws Exception {
        PubGetSwryxxReturnDomain returnDomain = new PubGetSwryxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pwWebjkWxfw10102Swryxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        String mess = "";
        String xm = "";
        String bgs = "";
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            mess = HstEncodeUtil.ISO2GBK((String)map.get("mess"));
            xm = HstEncodeUtil.ISO2GBK((String)map.get("xm"));
            bgs = HstEncodeUtil.ISO2GBK((String)map.get("bgs"));
        } else {
            mess = (String)map.get("mess");
            xm = (String)map.get("xm");
            bgs = (String)map.get("bgs");
        }
        returnDomain.setMess(mess);
        returnDomain.setXm(xm);
        returnDomain.setPy((String)map.get("py"));
        returnDomain.setBgs(bgs);
        returnDomain.setGddh((String)map.get("gddh"));
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain PubGetHysxx(PubGetHysxxAppDomain domain) throws Exception {
        PubGetHysxxReturnDomain returnDomain = new PubGetHysxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("hysjq", domain.getHysjq());
        map.put("hysjz", domain.getHysjz());
        this.sqlMapClientTemplate.queryForObjectByCurr("pwWebjkWxfw10103Hysxx", "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 PubGetNsrjyxx(PubGetNsrjyxxAppDomain domain) throws Exception {
        PubGetNsrjyxxReturnDomain returnDomain = new PubGetNsrjyxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("nsrsbh", domain.getNsrsbh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pwWebjkWxfw10104Nsrjyxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        if ("00".equals(returnDomain.getCode())) {
            returnDomain.setNsrsbh(((PubGetNsrjyxxReturnDomain)dataList.get(0)).getNsrsbh());
            returnDomain.setNsrmc(((PubGetNsrjyxxReturnDomain)dataList.get(0)).getNsrmc());
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain PubGetSwryList(PubGetSwryListAppDomain domain) throws Exception {
        PubGetSwryListReturnDomain returnDomain = new PubGetSwryListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ryfl", domain.getRyfl());
        this.sqlMapClientTemplate.queryForObjectByCurr("pwWebjkWxfw10105SwryList", "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 QdqtSwryDqzt(QdqtSwryDqztAppDomain domain) throws Exception {
        QdqtSwryDqztReturnDomain returnDomain = new QdqtSwryDqztReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pwWebjkWxfw10201Dqzt", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain QdqtSwryQdqt(QdqtSwryQdqtAppDomain domain) throws Exception {
        QdqtSwryQdqtReturnDomain returnDomain = new QdqtSwryQdqtReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("qdqtbz", domain.getQdqtbz());
        map.put("rq", domain.getRq());
        map.put("sj", domain.getSj());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("dd", HstEncodeUtil.GBK2ISO(domain.getDd()));
            map.put("bz", HstEncodeUtil.GBK2ISO(domain.getBz()));
        } else {
            map.put("dd", domain.getDd());
            map.put("bz", domain.getBz());
        }
        map.put("jd", domain.getJd());
        map.put("wd", domain.getWd());
        this.sqlMapClientTemplate.queryForObject("pwWebjkWxfw10202Ddqt", map);
        returnDomain.setCode((String)map.get("code"));
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain QdqtSwrySgqx(QdqtSwrySgqxAppDomain domain) throws Exception {
        QdqtSwrySgqxReturnDomain returnDomain = new QdqtSwrySgqxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sgqxdm", domain.getSgqxdm());
        map.put("rq", domain.getRq());
        map.put("sj", domain.getSj());
        map.put("jd", domain.getJd());
        map.put("wd", domain.getWd());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("dd", HstEncodeUtil.GBK2ISO(domain.getDd()));
            map.put("bz", HstEncodeUtil.GBK2ISO(domain.getBz()));
        } else {
            map.put("dd", domain.getDd());
            map.put("bz", domain.getBz());
        }
        this.sqlMapClientTemplate.queryForObject("pwWebjkWxfw10203Sgqx", map);
        returnDomain.setCode((String)map.get("code"));
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain QdqtSwryQdqtLog(QdqtSwryQdqtLogAppDomain domain) throws Exception {
        QdqtSwryQdqtLogReturnDomain returnDomain = new QdqtSwryQdqtLogReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pwWebjkWxfw10204Ddqtlog", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setCode((String)map.get("code"));
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxJbsqSave(WbsxJbsqSaveAppDomain domain) throws Exception {
        WbsxJbsqSaveReturnDomain returnDomain = new WbsxJbsqSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sqrq", domain.getSqrq());
        map.put("sqjbsjq", domain.getSqjbsjq());
        map.put("sqjbsjz", domain.getSqjbsjz());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("sqjbyy", HstEncodeUtil.GBK2ISO(domain.getSqjbyy()));
        } else {
            map.put("sqjbyy", domain.getSqjbyy());
        }
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10401JbsqSave", map);
        returnDomain.setCode((String)map.get("code"));
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setMess(mess);
        returnDomain.setSxsqxh((String)map.get("sxsqxh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxJbysqxx(WbsxJbysqxxAppDomain domain) throws Exception {
        WbsxJbysqxxReturnDomain returnDomain = new WbsxJbysqxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10402Jbysqxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            returnDomain.setDataList(dataList);
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxJbsqCxmx(WbsxJbsqCxmxAppDomain domain) throws Exception {
        WbsxJbsqCxmxReturnDomain returnDomain = new WbsxJbsqCxmxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10403JbsqCxmx", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        HstEncodeUtil.conISO2GBK(returnDomain);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxJbsqQx(WbsxJbsqQxAppDomain domain) throws Exception {
        WbsxJbsqQxReturnDomain returnDomain = new WbsxJbsqQxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10404JbsqQx", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxQjsqSave(WbsxQjsqSaveAppDomain domain) throws Exception {
        WbsxQjsqSaveReturnDomain returnDomain = new WbsxQjsqSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sqrq", domain.getSqrq());
        map.put("qjlxdm", domain.getQjlxdm());
        map.put("sqqjsjq", domain.getSqqjsjq());
        map.put("sqqjsjz", domain.getSqqjsjz());
        map.put("sqqjyy", HstEncodeUtil.GBK2ISO(domain.getSqqjyy()));
        map.put("sqqjts", domain.getSqqjts());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10405QjsqSave", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setSxsqxh((String)map.get("sxsqxh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxQjsqCx(WbsxQjsqCxAppDomain domain) throws Exception {
        WbsxQjsqCxReturnDomain returnDomain = new WbsxQjsqCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10406Qjsqcx", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        HstEncodeUtil.conISO2GBK(returnDomain);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxXjsqSave(WbsxXjsqSaveAppDomain domain) throws Exception {
        WbsxXjsqSaveReturnDomain returnDomain = new WbsxXjsqSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("oldSxsqxh", domain.getOldsxsqxh());
        map.put("sqrq", domain.getSqrq());
        map.put("sjqjsjq", domain.getSjqjsjq());
        map.put("sjqjsjz", domain.getSjqjsjz());
        map.put("sqxjyy", HstEncodeUtil.GBK2ISO(domain.getSqxjyy()));
        map.put("sjqjts", domain.getSjqjts());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10407XjsqSave", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setSxsqxh((String)map.get("sxsqxh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxQxjysqxx(WbsxQxjysqxxAppDomain domain) throws Exception {
        WbsxQxjysqxxReturnDomain returnDomain = new WbsxQxjysqxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10408Qxjysqxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            returnDomain.setDataList(dataList);
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxQjsqmx(WbsxQjsqmxAppDomain domain) throws Exception {
        WbsxQjsqmxReturnDomain returnDomain = new WbsxQjsqmxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10409Qjsqmx", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        HstEncodeUtil.conISO2GBK(returnDomain);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxXjsqmx(WbsxXjsqmxAppDomain domain) throws Exception {
        WbsxXjsqmxReturnDomain returnDomain = new WbsxXjsqmxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10410Xjsqmx", map, "dataList", "returnDomain");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code)) {
            List dataList = (List)map.get("dataList");
            BeanUtils.copyProperties((Object)returnDomain, ((List)map.get("returnDomain")).get(0));
            returnDomain.setDataList(dataList);
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxQxjQx(WbsxQxjQxAppDomain domain) throws Exception {
        WbsxQxjQxReturnDomain returnDomain = new WbsxQxjQxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        map.put("qxjbz", domain.getQxjbz());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10411Qxjqx", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxYcsqSave(WbsxYcsqSaveAppDomain domain) throws Exception {
        WbsxYcsqSaveReturnDomain returnDomain = new WbsxYcsqSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sqrq", domain.getSqrq());
        map.put("sqycsjq", domain.getSqycsjq());
        map.put("sqycsjz", domain.getSqycsjz());
        map.put("ycrsl", domain.getYcrsl());
        map.put("cfd", HstEncodeUtil.GBK2ISO(domain.getCfd()));
        map.put("mdd", HstEncodeUtil.GBK2ISO(domain.getMdd()));
        map.put("bz", HstEncodeUtil.GBK2ISO(domain.getBz()));
        map.put("shiy", HstEncodeUtil.GBK2ISO(domain.getShiy()));
        map.put("sfpc", domain.getSfpc());
        map.put("old_pc_djxh", domain.getOld_pc_djxh());
        map.put("sfdd", domain.getSfdd());
        map.put("ddycsjq", domain.getDdycsjq());
        map.put("ddycsjz", domain.getDdqycsjz());
        StringBuffer ycrbuff = new StringBuffer();
        for (WbsxYcsqSaveYcrDomain dom : domain.getDataList()) {
            ycrbuff.append(dom.getYcr_swrydm()).append(",");
        }
        String ycrdmList = "";
        if (ycrbuff.length() > 0) {
            ycrdmList = ycrbuff.substring(0, ycrbuff.length() - 1);
        }
        map.put("ycrdmList", ycrdmList);
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10412YcsqSave", "dataList", map);
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setSxsqxh((String)map.get("sxsqxh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxYcysqxx(WbsxYcysqxxAppDomain domain) throws Exception {
        WbsxYcysqxxReturnDomain returnDomain = new WbsxYcysqxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10413Ycysqxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            returnDomain.setDataList(dataList);
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxYcsqCxmx(WbsxYcsqCxmxAppDomain domain) throws Exception {
        WbsxYcsqCxmxReturnDomain returnDomain = new WbsxYcsqCxmxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10414YcsqCxmx", map, "retudnDomain", "dataList");
        BeanUtils.copyProperties((Object)returnDomain, ((List)map.get("retudnDomain")).get(0));
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxYcsqQx(WbsxYcsqQxAppDomain domain) throws Exception {
        WbsxYcsqQxReturnDomain returnDomain = new WbsxYcsqQxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10415YcsqQx", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxHyssqSave(WbsxHyssqSaveAppDomain domain) throws Exception {
        WbsxHyssqSaveReturnDomain returnDomain = new WbsxHyssqSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sqrq", domain.getSqrq());
        map.put("sqsysjq", domain.getSqsysjq());
        map.put("sqsysjz", domain.getSqsysjz());
        map.put("hysm", HstEncodeUtil.GBK2ISO(domain.getHysm()));
        map.put("flag", domain.getFlag());
        map.put("hysdjxh", domain.getHysdjxh());
        map.put("dd", HstEncodeUtil.GBK2ISO(domain.getDd()));
        map.put("zrfy", domain.getZrfy());
        map.put("bz", HstEncodeUtil.GBK2ISO(domain.getBz()));
        map.put("sfyjsb", domain.getSfyjsb());
        map.put("hybt", HstEncodeUtil.GBK2ISO(domain.getHybt()));
        map.put("chrybz", domain.getChrybz());
        String chrList = "";
        for (WbsxHyssqSaveChrDomain dom : domain.getDataList()) {
            chrList = String.valueOf(chrList) + dom.getChr_swrydm() + ",";
        }
        if (chrList.length() > 0) {
            chrList = chrList.substring(0, chrList.length() - 1);
        }
        map.put("chrList", chrList);
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10416HysqSave", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setSxsqxh((String)map.get("sxsqxh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxHysysqxx(WbsxHysysqxxAppDomain domain) throws Exception {
        WbsxHysysqxxReturnDomain returnDomain = new WbsxHysysqxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10417Hysysqxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            returnDomain.setDataList(dataList);
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxHyssqCxmx(WbsxHyssqCxmxAppDomain domain) throws Exception {
        WbsxHyssqCxmxReturnDomain returnDomain = new WbsxHyssqCxmxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10418HyssqCxmx", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        HstEncodeUtil.conISO2GBK(returnDomain);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxHyssqQx(WbsxHyssqQxAppDomain domain) throws Exception {
        WbsxHyssqQxReturnDomain returnDomain = new WbsxHyssqQxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10419HyssqQx", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxSmhcsqSave(WbsxSmhcsqSaveAppDomain domain) throws Exception {
        WbsxSmhcsqSaveReturnDomain returnDomain = new WbsxSmhcsqSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sqrq", domain.getSqrq());
        map.put("hcsx", HstEncodeUtil.GBK2ISO(domain.getHcsx()));
        map.put("hcrq", domain.getHcrq());
        map.put("nsrsbh", domain.getNsrsbh());
        map.put("hcrydmlist", domain.getHcrydmlist());
        map.put("bz", HstEncodeUtil.GBK2ISO(domain.getBz()));
        map.put("sfffjdk", domain.getSfffjdk());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10420SmhcsqSave", map);
        returnDomain.setCode((String)map.get("code"));
        returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        returnDomain.setSxsqxh((String)map.get("sxsqxh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxSmhcysqxx(WbsxSmhcysqxxAppDomain domain) throws Exception {
        WbsxSmhcysqxxReturnDomain returnDomain = new WbsxSmhcysqxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10421Smhcysqxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            returnDomain.setDataList(dataList);
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxSmhcsqCxmx(WbsxSmhcsqCxmxAppDomain domain) throws Exception {
        WbsxSmhcsqCxmxReturnDomain returnDomain = new WbsxSmhcsqCxmxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10422SmhcsqCxmx", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        HstEncodeUtil.conISO2GBK(returnDomain);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxSmhcsqQx(WbsxSmhcsqQxAppDomain domain) throws Exception {
        WbsxSmhcsqQxReturnDomain returnDomain = new WbsxSmhcsqQxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10423SmhcsqQx", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxYyfwapxx(WbsxYyfwapxxAppDomain domain) throws Exception {
        WbsxYyfwapxxReturnDomain returnDomain = new WbsxYyfwapxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pwebJkWxfw1024Yyfwapxx", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        HstEncodeUtil.conISO2GBK(returnDomain);
        if ("00".equals(returnDomain.getCode()) && returnDomain.getDataList().size() == 0) {
            ArrayList<WbsxYyfwapxxDomain> dataList = new ArrayList<WbsxYyfwapxxDomain>();
            int dayOfWeek = TaxWxqyhAppDaoImp.getMondayPlus();
            int i = 0;
            while (i < 7) {
                WbsxYyfwapxxDomain dom1 = new WbsxYyfwapxxDomain();
                String rq = HstDateUtil.getIntervalDate(HstDateUtil.getCurrentDate(), 5, dayOfWeek + 7 + i);
                dom1.setRq(rq);
                dom1.setSxwbz("1");
                dom1.setRsmax("");
                WbsxYyfwapxxDomain dom2 = new WbsxYyfwapxxDomain();
                dom2.setRq(rq);
                dom2.setSxwbz("2");
                dom2.setRsmax("");
                dataList.add(dom1);
                dataList.add(dom2);
                ++i;
            }
            returnDomain.setDataList(dataList);
        }
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxYyfwapSave(WbsxYyfwapSaveAppDomain domain) throws Exception {
        WbsxYyfwapSaveReturnDomain returnDomain = new WbsxYyfwapSaveReturnDomain();
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        for (WbsxYyfwapSaveDomain dom : domain.getDataList()) {
            FwhYyfwYysjfb bo = new FwhYyfwYysjfb();
            BeanUtils.copyProperties((Object)bo, (Object)dom);
            bo.setDatabaseUsername(databaseUsername);
            bo.setCzryDm(domain.getSwrydm());
            this.sqlMapClientTemplate.delete("deleteYyfwYyfwYysjfbByKey", bo);
            this.sqlMapClientTemplate.insert("insertFwhYyfwYysjfb", bo);
        }
        returnDomain.setCode("00");
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxYyfwYyyxx(WbsxYyfwYyyxxAppDomain domain) throws Exception {
        WbsxYyfwYyyxxReturnDomain returnDomain = new WbsxYyfwYyyxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10426Yyfwyyyxx", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        HstEncodeUtil.conISO2GBK(returnDomain);
        return returnDomain;
    }

    public TaxCommonReturnDomain WbsxYyfwYynsr(WbsxYyfwYynsrAppDomain domain) throws Exception {
        WbsxYyfwYynsrReturnDomain returnDomain = new WbsxYyfwYynsrReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("rq", domain.getRq());
        map.put("sxwbz", domain.getSxwbz());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10427YyfwyyNsr", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        HstEncodeUtil.conISO2GBK(returnDomain);
        return returnDomain;
    }

    private static int getMondayPlus() {
        Calendar cd = Calendar.getInstance();
        cd.setTime(new Date());
        int dayOfWeek = cd.get(7);
        if (dayOfWeek == 1) {
            return -7;
        }
        return 1 - dayOfWeek;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxSltjCx(YbsxSltjCxAppDomain domain) throws Exception {
        YbsxSltjCxReturnDomain returnDomain = new YbsxSltjCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10501Sltjcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        if ("00".equals(code)) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxGztxCx(YbsxGztxCxAppDomain domain) throws Exception {
        YbsxGztxCxReturnDomain returnDomain = new YbsxGztxCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        map.put("ckbz", domain.getCkbz());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10502GztxCx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxDbrwCx(YbsxDbrwCxAppDomain domain) throws Exception {
        YbsxDbrwCxReturnDomain returnDomain = new YbsxDbrwCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        map.put("wcbz", domain.getWcbz());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10503Dbrwcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxDbrwWcSave(YbsxDbrwWcSaveAppDomain domain) throws Exception {
        WbsxSmhcsqQxReturnDomain returnDomain = new WbsxSmhcsqQxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("dbrwXh", domain.getDbrw_xh());
        map.put("wcqksm", HstEncodeUtil.GBK2ISO(domain.getWcqksm()));
        map.put("dd", HstEncodeUtil.GBK2ISO(domain.getDd()));
        map.put("jd", domain.getJd());
        map.put("wd", domain.getWd());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10504DbrwSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxDpsxCx(YbsxDpsxCxAppDomain domain) throws Exception {
        YbsxDpsxCxReturnDomain returnDomain = new YbsxDpsxCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        map.put("spbz", domain.getSpbz());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10505DpsxCx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxDpsxSpxxCx(YbsxDpsxSpxxCxAppDomain domain) throws Exception {
        YbsxDpsxSpxxCxReturnDomain returnDomain = new YbsxDpsxSpxxCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("sqsxXh", domain.getSxsq_xh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10506SpxxCx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxDpsxSptj(YbsxDpsxSptjAppDomain domain) throws Exception {
        WbsxSmhcsqQxReturnDomain returnDomain = new WbsxSmhcsqQxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("sxsqXh", domain.getSxsq_xh());
        map.put("sprSwryDm", domain.getSpr_swry_dm());
        map.put("spjg", domain.getSpjg());
        map.put("spyj", HstEncodeUtil.GBK2ISO(domain.getSpyj()));
        map.put("zsbz", domain.getZsbz());
        map.put("dqSpxh", domain.getDq_spxh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10507DpsxSptj", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxXxList(GrzxXxListAppDomain domain) throws Exception {
        GrzxXxListReturnDomain returnDomain = new GrzxXxListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10301Xxlist", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxXxMx(GrzxXxMxAppDomain domain) throws Exception {
        GrzxXxMxReturnDomain returnDomain = new GrzxXxMxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("dfSwryDm", domain.getDf_swry_dm());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10302XxMx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxXxHf(GrzxXxHfAppDomain domain) throws Exception {
        GrzxXxHfReturnDomain returnDomain = new GrzxXxHfReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("dfSwryDm", domain.getDf_swry_dm());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("fsnr", HstEncodeUtil.GBK2ISO(domain.getFsnr()));
        } else {
            map.put("fsnr", domain.getFsnr());
        }
        map.put("xxlx", domain.getXxlx());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10303XxHf", map);
        String code = (String)map.get("code");
        returnDomain.setCode(code);
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            returnDomain.setMess(HstEncodeUtil.ISO2GBK((String)map.get("mess")));
        } else {
            returnDomain.setMess((String)map.get("mess"));
        }
        returnDomain.setXxdj_xh((String)map.get("xxdjXh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxFxList(GrzxFxListAppDomain domain) throws Exception {
        GrzxFxListReturnDomain returnDomain = new GrzxFxListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10304FxList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List<GrzxFxListDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        if (dataList.size() > 0) {
            String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
            for (GrzxFxListDomain dom : dataList) {
                HashMap<String, String> map2 = new HashMap<String, String>();
                map2.put("fxdj_xh", dom.getFxdj_xh());
                map2.put("databaseUsername", databaseUsername);
                List fjList = this.sqlMapClientTemplate.queryForList("selectWxfwGrzxFxlistFj", map2);
                List bmList = this.sqlMapClientTemplate.queryForList("selectWxfwGrzxFxlistBm", map2);
                List czyList = this.sqlMapClientTemplate.queryForList("selectWxfwGrzxFxlistFjCzy", map2);
                List hfList = this.sqlMapClientTemplate.queryForList("selectWxfwGrzxFxlistFjHf", map2);
                dom.setFjList(fjList);
                dom.setBmList(bmList);
                dom.setCzyList(czyList);
                dom.setHfList(hfList);
            }
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxFxfjcx(GrzxFxfjcxAppDomain domain) throws Exception {
        GrzxFxfjcxReturnDomain returnDomain = new GrzxFxfjcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("fxdjXh", domain.getFxdj_xh());
        map.put("fjxh", domain.getFjxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10305fjcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        if (dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxFxSave(GrzxFxSaveAppDomain domain) throws Exception {
        GrzxFxSaveReturnDomain returnDomain = new GrzxFxSaveReturnDomain();
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        QyhWdsxFx fx = new QyhWdsxFx();
        fx.setFsr_swry_dm(domain.getSwrydm());
        fx.setFxnr(domain.getFxnr());
        fx.setFxlb_dm(domain.getFxlb_dm());
        fx.setSwjg_dm(domain.getSwjgdm());
        fx.setDatabaseUsername(databaseUsername);
        fx.setYxbz("Y");
        String fxdj_xh = "";
        if (StringUtils.isBlank((String)domain.getFxdj_xh())) {
            this.sqlMapClientTemplate.insert("insertQyhWdsxFx", fx);
            fxdj_xh = fx.getFxdj_xh();
        } else {
            fxdj_xh = domain.getFxdj_xh();
            fx.setFxdj_xh(fxdj_xh);
            this.sqlMapClientTemplate.update("updateQyhWdsxFx", fx);
            HashMap<String, String> map = new HashMap<String, String>();
            map.put("fxdj_xh", fxdj_xh);
            map.put("databaseUsername", databaseUsername);
            this.sqlMapClientTemplate.delete("deleteQyhWdsxFxFj", map);
            this.sqlMapClientTemplate.delete("deleteQyhWdsxFxBm", map);
            this.sqlMapClientTemplate.delete("deleteQyhWdsxFxGr", map);
        }
        for (GrzxFxSaveFjDomain fjDom : domain.getFjList()) {
            if (StringUtils.isBlank((String)fjDom.getFjxh())) continue;
            QyhWdsxFxFj fj = new QyhWdsxFxFj();
            BeanUtils.copyProperties((Object)fj, (Object)fjDom);
            fj.setFxdj_xh(fxdj_xh);
            fj.setFjxh(fjDom.getFjxh());
            fj.setWjlx_dm(fjDom.getWjlx_dm());
            fj.setWjnr(fjDom.getWjnr().replaceAll("\r\n", "").replaceAll("\\s", "\\+").replaceAll("\\+", "%2B"));
            fj.setDatabaseUsername(databaseUsername);
            this.sqlMapClientTemplate.insert("insertQyhWdsxFxFj", fj);
        }
        for (GrzxFxSaveBmDomain bmDom : domain.getBmList()) {
            if (StringUtils.isBlank((String)bmDom.getSwbm_dm())) continue;
            QyhWdsxFxBm bm = new QyhWdsxFxBm();
            bm.setSwbm_dm(bmDom.getSwbm_dm());
            bm.setDatabaseUsername(databaseUsername);
            bm.setFxdj_xh(fxdj_xh);
            this.sqlMapClientTemplate.insert("insertQyhWdsxFxBm", bm);
        }
        for (GrzxFxSaveCzyDomain grDm : domain.getCzyList()) {
            if (StringUtils.isBlank((String)grDm.getSwry_dm())) continue;
            QyhWdsxFxGr gr = new QyhWdsxFxGr();
            gr.setSwry_dm(grDm.getSwry_dm());
            gr.setDatabaseUsername(databaseUsername);
            gr.setFxdj_xh(fxdj_xh);
            this.sqlMapClientTemplate.insert("insertQyhWdsxFxGr", gr);
        }
        returnDomain.setFxdj_xh(fxdj_xh);
        returnDomain.setCode("00");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxFxDelete(GrzxFxDeleteAppDomain domain) throws Exception {
        GrzxFxDeleteReturnDomain returnDomain = new GrzxFxDeleteReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("fxdjXh", domain.getFxdj_xh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10307FxDelete", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxRcList(GrzxRcListAppDomain domain) throws Exception {
        GrzxRcListReturnDomain returnDomain = new GrzxRcListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10308RcLsit", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxRcSave(GrzxRcSaveAppDomain domain) throws Exception {
        GrzxRcSaveReturnDomain returnDomain = new GrzxRcSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swrydm", domain.getSwrydm());
        map.put("rcdjXh", domain.getRcdj_xh());
        map.put("rcsj", domain.getRcsj());
        map.put("rcnr", HstEncodeUtil.GBK2ISO(domain.getRcnr()));
        map.put("sftx", domain.getSftx());
        map.put("txsjDm", domain.getTxsj_dm());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10309RcSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setRcdj_xh((String)map.get("rcdjXh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxRzList(GrzxRzListAppDomain domain) throws Exception {
        GrzxRzListReturnDomain returnDomain = new GrzxRzListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10310RzLsit", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxRzSave(GrzxRzSaveAppDomain domain) throws Exception {
        GrzxRzSaveReturnDomain returnDomain = new GrzxRzSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swrydm", domain.getSwrydm());
        map.put("rzdjXh", domain.getRzdj_xh());
        map.put("rq", domain.getRq());
        map.put("rznr", HstEncodeUtil.GBK2ISO(domain.getRznr()));
        map.put("zszt", HstEncodeUtil.GBK2ISO(domain.getZszt()));
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10311RzSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setRzdj_xh((String)map.get("rzdjXh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxRzCsrz(GrzxRzCsrzAppDomain domain) throws Exception {
        GrzxRzCsrzReturnDomain returnDomain = new GrzxRzCsrzReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swrydm", domain.getSwrydm());
        map.put("rq", domain.getRq());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10312Csrz", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setRznr(HstEncodeUtil.ISO2GBK((String)map.get("rznr")));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain PubSaveSwry(PubSaveSwryAppDomain domain) throws Exception {
        PubSaveSwryReturnDomain returnDomain = new PubSaveSwryReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("openId", domain.getOpenId());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("nickName", HstEncodeUtil.GBK2ISO(domain.getNickName()));
        } else {
            map.put("nickName", domain.getNickName());
        }
        map.put("city", domain.getCity());
        map.put("country", domain.getCountry());
        map.put("province", domain.getProvince());
        map.put("subscribeDay", domain.getSubscribeDay());
        map.put("subscribeTime", domain.getSubscribeTime());
        map.put("remark", domain.getRemark());
        map.put("groupid", domain.getGroupid());
        map.put("head_pic", domain.getHead_pic());
        this.sqlMapClientTemplate.queryForObject("pwWebjkWxfw10106SaveSwry", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwTzList(WddwTzListAppDomain domain) throws Exception {
        WddwTzListReturnDomain returnDomain = new WddwTzListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10601WddwTzList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwFxList(WddwFxListAppDomain domain) throws Exception {
        WddwFxListReturnDomain returnDomain = new WddwFxListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10602WddwFxList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List<WddwFxListDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        if (dataList.size() > 0) {
            String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
            for (WddwFxListDomain dom : dataList) {
                HashMap<String, String> map2 = new HashMap<String, String>();
                map2.put("fxdj_xh", dom.getFxdj_xh());
                map2.put("databaseUsername", databaseUsername);
                List fjList = this.sqlMapClientTemplate.queryForList("selectWxfwGrzxFxlistFj", map2);
                List hfList = this.sqlMapClientTemplate.queryForList("selectWxfwGrzxFxlistFjHf", map2);
                dom.setFjList(fjList);
                dom.setHfList(hfList);
            }
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwFxDzSave(WddwFxDzSaveAppDomain domain) throws Exception {
        WddwFxDzSaveReturnDomain returnDomain = new WddwFxDzSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("fxdj_xh", domain.getFxdj_xh());
        map.put("dzbz", domain.getDzbz());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10604WddwFxdzSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwFxPlSave(WddwFxPlSaveAppDomain domain) throws Exception {
        WddwFxPlSaveReturnDomain returnDomain = new WddwFxPlSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("fxdj_xh", domain.getFxdj_xh());
        map.put("hfnr", HstEncodeUtil.GBK2ISO(domain.getHfnr()));
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10605WddwPlSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwTxlList(WddwTxlListAppDomain domain) throws Exception {
        WddwTxlListReturnDomain returnDomain = new WddwTxlListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("swbmdm", domain.getSwbmdm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10606WddwTxlList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwQxList(WddwQxListAppDomain domain) throws Exception {
        WddwQxListReturnDomain returnDomain = new WddwQxListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("swbmdm", domain.getSwbmdm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10607WddwQxList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHysList(WddwHysListAppDomain domain) throws Exception {
        WddwHysListReturnDomain returnDomain = new WddwHysListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10608WddwHysList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        for (WddwHysListDomain dom : dataList) {
            map.put("hys_djxh", dom.getHys_djxh());
            this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10608WddwHysApxx", "dataList", map);
            List hyapList = (List)map.get("dataList");
            dom.setHyapList(hyapList);
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwClList(WddwClListAppDomain domain) throws Exception {
        WddwClListReturnDomain returnDomain = new WddwClListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10609WddwClList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        for (WddwClListDomain dom : dataList) {
            map.put("cl_djxh", dom.getCl_djxh());
            this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10609WddwClApxx", "dataList", map);
            List clapList = (List)map.get("dataList");
            dom.setClapList(clapList);
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdList(WddwHdListAppDomain domain) throws Exception {
        WddwHdListReturnDomain returnDomain = new WddwHdListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10610WddwHdList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List<WddwHdListDomain> dataList = new ArrayList();
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        dataList = (List)map.get("dataList");
        map.put("databaseUsername", databaseUsername);
        if (dataList.size() > 0) {
            for (WddwHdListDomain dom : dataList) {
                map.put("hddj_xh", dom.getHddj_xh());
                List fjList = this.sqlMapClientTemplate.queryForList("selectWxfwWddwHdFj", map);
                List hfList = this.sqlMapClientTemplate.queryForList("selectWxfwWddwHdCyry", map);
                List cyList = this.sqlMapClientTemplate.queryForList("selectWxfwWddwHdHf", map);
                dom.setFjList(fjList);
                dom.setHfList(hfList);
                dom.setCyList(cyList);
            }
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdfjcx(WddwHdfjcxAppDomain domain) throws Exception {
        WddwHdfjcxReturnDomain returnDomain = new WddwHdfjcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("hddj_xh", domain.getHddj_xh());
        map.put("fjxh", domain.getFjxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10611WddwHdfjcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        if (dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdcyrycx(WddwHdcyrycxAppDomain domain) throws Exception {
        WddwHdcyrycxReturnDomain returnDomain = new WddwHdcyrycxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("hddj_xh", domain.getHddj_xh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10612WddwHdrycx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdDzSave(WddwHdDzSaveAppDomain domain) throws Exception {
        WddwHdDzSaveReturnDomain returnDomain = new WddwHdDzSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("hddj_xh", domain.getHddj_xh());
        map.put("dzbz", domain.getDzbz());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10613WddwHddzSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdPlSave(WddwHdPlSaveAppDomain domain) throws Exception {
        WddwHdPlSaveReturnDomain returnDomain = new WddwHdPlSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("hddj_xh", domain.getHddj_xh());
        map.put("hfnr", HstEncodeUtil.GBK2ISO(domain.getHfnr()));
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10614WddwHdPlSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdFbSave(WddwHdFbSaveAppDomain domain) throws Exception {
        WddwHdFbSaveReturnDomain returnDomain = new WddwHdFbSaveReturnDomain();
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        QyhWddwHd tz = new QyhWddwHd();
        tz.setFqr_swry_dm(domain.getSwrydm());
        tz.setHdnr(domain.getHdnr());
        tz.setHdkssj(domain.getHdkssj());
        tz.setHdjssj(domain.getHdjssj());
        tz.setJsdxbz(domain.getJsdxbz());
        tz.setSwjg_dm(domain.getSwjgdm());
        tz.setDatabaseUsername(databaseUsername);
        tz.setYxbz("Y");
        tz.setPl_sl("0");
        tz.setZ_zl("0");
        tz.setCyry_sl("0");
        String hddj_xh = "";
        if (StringUtils.isBlank((String)domain.getHddj_xh())) {
            this.sqlMapClientTemplate.insert("insertQyhWddwHd", tz);
            hddj_xh = tz.getHddj_xh();
        } else {
            hddj_xh = domain.getHddj_xh();
            tz.setHddj_xh(hddj_xh);
            this.sqlMapClientTemplate.update("updateQyhWddwHd", tz);
            HashMap<String, String> map = new HashMap<String, String>();
            map.put("hddj_xh", hddj_xh);
            map.put("databaseUsername", databaseUsername);
            this.sqlMapClientTemplate.delete("deleteQyhWddwHdFj", map);
            this.sqlMapClientTemplate.delete("deleteQyhWddwHdBm", map);
            this.sqlMapClientTemplate.delete("deleteQyhWddwHdGr", map);
        }
        for (WddwHdFbSaveFjDomain fjDom : domain.getFjList()) {
            if (StringUtils.isBlank((String)fjDom.getFjxh())) continue;
            QyhWddwHdFj fj = new QyhWddwHdFj();
            BeanUtils.copyProperties((Object)fj, (Object)fjDom);
            fj.setHddj_xh(hddj_xh);
            fj.setFjxh(fjDom.getFjxh());
            fj.setWjlx_dm(fjDom.getWjlx_dm());
            fj.setWjnr(fjDom.getWjnr().replaceAll("\r\n", "").replaceAll("\\s", "\\+").replaceAll("\\+", "%2B"));
            fj.setDatabaseUsername(databaseUsername);
            this.sqlMapClientTemplate.insert("insertQyhWddwHdFj", fj);
        }
        for (WddwHdFbSaveBmDomain bmDom : domain.getBmList()) {
            if (StringUtils.isBlank((String)bmDom.getSwbm_dm())) continue;
            QyhWddwHdBm bm = new QyhWddwHdBm();
            bm.setSwbm_dm(bmDom.getSwbm_dm());
            bm.setDatabaseUsername(databaseUsername);
            bm.setHddj_xh(hddj_xh);
            this.sqlMapClientTemplate.insert("insertQyhWddwHdBm", bm);
        }
        for (WddwHdFbSaveCzyDomain grDm : domain.getCzyList()) {
            if (StringUtils.isBlank((String)grDm.getSwry_dm())) continue;
            QyhWddwHdGr gr = new QyhWddwHdGr();
            gr.setSwry_dm(grDm.getSwry_dm());
            gr.setDatabaseUsername(databaseUsername);
            gr.setHddj_xh(hddj_xh);
            this.sqlMapClientTemplate.insert("insertQyhWddwHdGr", gr);
        }
        returnDomain.setHddj_xh(hddj_xh);
        returnDomain.setCode("00");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdDelete(WddwHdDeleteAppDomain domain) throws Exception {
        WddwHdDeleteReturnDomain returnDomain = new WddwHdDeleteReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("hddj_xh", domain.getHddj_xh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10616WddwHdDel", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdBmSave(WddwHdBmSaveAppDomain domain) throws Exception {
        WddwHdBmSaveReturnDomain returnDomain = new WddwHdBmSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("hddj_xh", domain.getHddj_xh());
        map.put("bm_swrydm", domain.getBm_swry_dm());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10617WddwHdBmSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WddwHdBmDelete(WddwHdBmDeleteAppDomain domain) throws Exception {
        WddwHdBmDeleteReturnDomain returnDomain = new WddwHdBmDeleteReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("hddj_xh", domain.getHddj_xh());
        map.put("bm_swrydm", domain.getBm_swry_dm());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10618WddwHdBmDel", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxTzcx(WbsxTzcxAppDomain domain) throws Exception {
        WbsxTzcxReturnDomain returnDomain = new WbsxTzcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        map.put("flag", domain.getFlag());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10428WbsxTzcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List<WbsxTzcxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        if (dataList.size() > 0) {
            String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
            for (WbsxTzcxDomain dom : dataList) {
                HashMap<String, String> map2 = new HashMap<String, String>();
                map2.put("tzdj_xh", dom.getTzdj_xh());
                map2.put("databaseUsername", databaseUsername);
                List fjList = this.sqlMapClientTemplate.queryForList("selectWddwTzFjByKey", map2);
                List bmList = this.sqlMapClientTemplate.queryForList("selectWddwTzBmByKey", map2);
                List czyList = this.sqlMapClientTemplate.queryForList("selectWddwTzFjczyKey", map2);
                dom.setFjList(fjList);
                dom.setBmList(bmList);
                dom.setCzyList(czyList);
            }
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxTzFjcx(WbsxTzFjcxAppDomain domain) throws Exception {
        WbsxTzFjcxReturnDomain returnDomain = new WbsxTzFjcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("tzdjXh", domain.getTzdj_xh());
        map.put("fjxh", domain.getFjxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10429TzFjcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        if (dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxTzSave(WbsxTzSaveAppDomain domain) throws Exception {
        HashMap<String, String> map;
        WbsxTzSaveReturnDomain returnDomain = new WbsxTzSaveReturnDomain();
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        QyhWddwTz tz = new QyhWddwTz();
        tz.setFsr_swry_dm(domain.getSwrydm());
        tz.setTznr(domain.getTznr());
        tz.setZt(domain.getZt());
        tz.setJsdxbz(domain.getJsdxbz());
        tz.setSwjg_dm(domain.getSwjgdm());
        tz.setDatabaseUsername(databaseUsername);
        tz.setYxbz("Y");
        String tzdj_xh = "";
        String bz = "";
        if (StringUtils.isBlank((String)domain.getTzdj_xh())) {
            this.sqlMapClientTemplate.insert("insertQyhWddwTz", tz);
            bz = "1";
            tzdj_xh = tz.getTzdj_xh();
        } else {
            bz = "2";
            tzdj_xh = domain.getTzdj_xh();
            tz.setTzdj_xh(tzdj_xh);
            this.sqlMapClientTemplate.update("updateQyhWddwTz", tz);
            map = new HashMap<String, String>();
            map.put("tzdj_xh", tzdj_xh);
            map.put("databaseUsername", databaseUsername);
            this.sqlMapClientTemplate.delete("deleteQyhWddwTzFj", map);
            this.sqlMapClientTemplate.delete("deleteQyhWddwTzBm", map);
            this.sqlMapClientTemplate.delete("deleteQyhWddwTzGr", map);
        }
        for (WbsxTzSaveFjDomain fjDom : domain.getFjList()) {
            if (StringUtils.isBlank((String)fjDom.getFjxh())) continue;
            QyhWddwTzFj fj = new QyhWddwTzFj();
            BeanUtils.copyProperties((Object)fj, (Object)fjDom);
            fj.setTzdj_xh(tzdj_xh);
            fj.setFjxh(fjDom.getFjxh());
            fj.setWjlx_dm(fjDom.getWjlx_dm());
            fj.setWjnr(fjDom.getWjnr().replaceAll("\r\n", "").replaceAll("\\s", "\\+").replaceAll("\\+", "%2B"));
            fj.setDatabaseUsername(databaseUsername);
            this.sqlMapClientTemplate.insert("insertQyhWddwTzFj", fj);
        }
        for (WbsxTzSaveBmDomain bmDom : domain.getBmList()) {
            if (StringUtils.isBlank((String)bmDom.getSwbm_dm())) continue;
            QyhWddwTzBm bm = new QyhWddwTzBm();
            bm.setSwbm_dm(bmDom.getSwbm_dm());
            bm.setDatabaseUsername(databaseUsername);
            bm.setTzdj_xh(tzdj_xh);
            this.sqlMapClientTemplate.insert("insertQyhWddwTzBm", bm);
        }
        for (WbsxTzSaveCzyDomain grDm : domain.getCzyList()) {
            if (StringUtils.isBlank((String)grDm.getSwry_dm())) continue;
            QyhWddwTzGr gr = new QyhWddwTzGr();
            gr.setSwry_dm(grDm.getSwry_dm());
            gr.setDatabaseUsername(databaseUsername);
            gr.setTzdj_xh(tzdj_xh);
            this.sqlMapClientTemplate.insert("insertQyhWddwTzGr", gr);
        }
        returnDomain.setTzdj_xh(tzdj_xh);
        returnDomain.setCode("00");
        map = new HashMap();
        map.put("tzdjXh", tzdj_xh);
        map.put("bz", bz);
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10430WbsxTzbccl", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxTzDelete(GrzxTzDeleteAppDomain domain) throws Exception {
        GrzxTzDeleteReturnDomain returnDomain = new GrzxTzDeleteReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("tzdj_xh", domain.getTzdj_xh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10431Tzelete", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxGztxSaveCkbz(YbsxGztxSaveCkbzAppDomain domain) throws Exception {
        YbsxGztxSaveCkbzReturnDomain returnDomain = new YbsxGztxSaveCkbzReturnDomain();
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        for (YbsxGztxSaveCkbzDomain dom : domain.getDataList()) {
            HashMap<String, String> map = new HashMap<String, String>();
            map.put("gztx_xh", dom.getGztx_xh());
            map.put("databaseUsername", databaseUsername);
            this.sqlMapClientTemplate.update("updateWddwGztxCkbz", map);
        }
        returnDomain.setCode("00");
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxGrszCx(GrzxGrszCxAppDomain domain) throws Exception {
        GrzxGrszCxReturnDomain returnDomain = new GrzxGrszCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10313Grszcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        ArrayList<GrzxGrszCxDomain> dataList = new ArrayList();
        dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxGrszSave(GrzxGrszSaveAppDomain domain) throws Exception {
        GrzxGrszSaveReturnDomain returnDomain = new GrzxGrszSaveReturnDomain();
        returnDomain.setCode("00");
        String zh = "";
        String pwd = "";
        for (GrzxGrszSaveDomain dom : domain.getDataList()) {
            if ("1001".equals(dom.getCsbm())) {
                zh = dom.getCsszz();
            }
            if (!"1002".equals(dom.getCsbm())) continue;
            pwd = dom.getCsszz();
        }
        if (StringUtils.isNotBlank((String)zh) && StringUtils.isNotBlank((String)pwd)) {
            String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
            HashMap<String, String> map = new HashMap<String, String>();
            map.put("swrydm", domain.getSwrydm());
            map.put("databaseUsername", databaseUsername);
            map.put("zh", zh);
            DesUtils des = new DesUtils("key=bskj");
            map.put("pwd", des.encrypt(pwd));
            this.sqlMapClientTemplate.update("updateGrzxGrszZh", map);
        }
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain PubGetBmqzRyxx(PubGetBmqzRyxxAppDomain domain) throws Exception {
        PubGetBmqzRyxxReturnDomain returnDomain = new PubGetBmqzRyxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10107Bmqzryxx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List cxList = (List)map.get("dataList");
        ArrayList<PubGetBmqzxxDomain> dataList = new ArrayList<PubGetBmqzxxDomain>();
        HashMap<String, PubGetBmqzxxDomain> bmqzbmMap = new HashMap<String, PubGetBmqzxxDomain>();
        PubGetBmqzxxDomain bmqzDom = null;
        PubGetBmqzRyxxDomain swryDom = null;
        for (PubGetBmqzxxCxDomain dom : cxList) {
            swryDom = new PubGetBmqzRyxxDomain();
            swryDom.setSwrydm(dom.getSwrydm());
            swryDom.setSwrymc(dom.getSwrymc());
            if (!bmqzbmMap.containsKey(dom.getBmqzbm())) {
                bmqzDom = new PubGetBmqzxxDomain();
                bmqzDom.setBmqzbm(dom.getBmqzbm());
                bmqzDom.setBmqzmc(dom.getBmqzmc());
                bmqzDom.setBmqzbz(dom.getBmqzbz());
                bmqzDom.getSwryList().add(swryDom);
                bmqzbmMap.put(dom.getBmqzbm(), bmqzDom);
                dataList.add(bmqzDom);
                continue;
            }
            bmqzDom = (PubGetBmqzxxDomain)bmqzbmMap.get(dom.getBmqzbm());
            bmqzDom.getSwryList().add(swryDom);
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxHyfbCx(YbsxHyfbCxAppDomain domain) throws Exception {
        YbsxHyfbCxReturnDomain returnDomain = new YbsxHyfbCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10510YbsxHyfbCx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List tempList = new ArrayList();
        tempList = (List)map.get("dataList");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        if (tempList == null || tempList.isEmpty()) {
            return returnDomain;
        }
        ArrayList<YbsxHyDomain> dataList = new ArrayList<YbsxHyDomain>();
        ArrayList<YbsxHyChrDomain> chrList = null;
        YbsxHyDomain dom = null;
        for (YbsxHyfbCxDomain temp : tempList) {
            dom = new YbsxHyDomain();
            BeanUtils.copyProperties((Object)dom, (Object)temp);
            if (!HstToolsUtil.isNullOrEmpty(temp.getChr_swry_dm())) {
                chrList = new ArrayList<YbsxHyChrDomain>();
                String[] array = temp.getChr_swry_dm().split(",");
                if (array != null && array.length > 0) {
                    chrList = new ArrayList();
                    YbsxHyChrDomain chr = null;
                    String[] stringArray = array;
                    int n = array.length;
                    int n2 = 0;
                    while (n2 < n) {
                        String str = stringArray[n2];
                        chr = new YbsxHyChrDomain();
                        chr.setChr_swry_dm(str);
                        chrList.add(chr);
                        ++n2;
                    }
                }
                dom.setChrList(chrList);
            }
            dataList.add(dom);
        }
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxHyfbBgchry(YbsxHyfbBgchryAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        StringBuffer chrSwryDm = new StringBuffer();
        if (!domain.getDataList().isEmpty()) {
            List<YbsxHyfbCwryDomain> dataList = domain.getDataList();
            int i = 0;
            while (i < dataList.size()) {
                if (dataList.size() == 1) {
                    chrSwryDm.append(dataList.get(i).getChr_swry_dm());
                } else if (i == dataList.size() - 1) {
                    chrSwryDm.append(dataList.get(i).getChr_swry_dm());
                } else {
                    chrSwryDm.append(dataList.get(i).getChr_swry_dm()).append(",");
                }
                ++i;
            }
        }
        map.put("hyfb_djxh", domain.getHyfb_djxh());
        map.put("chrSwryDm", chrSwryDm.toString());
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10511YbsxHyfbBgchry", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxHyfbSchyjy(YbsxHyfbSchyjyAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("hyfb_djxh", domain.getHyfb_djxh());
        map.put("hyjy", HstEncodeUtil.GBK2ISO(domain.getHyjy()));
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10512YbsxHyfbSchyjy", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxWdhyCx(GrzxWdhyCxAppDomain domain) throws Exception {
        GrzxWdhyCxReturnDomain returnDomain = new GrzxWdhyCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10315GrzxHysList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxWdhyBgchry(GrzxWdhyBgchryAppDomain domain) throws Exception {
        GrzxWdhyBgchryReturnDomain returnDomain = new GrzxWdhyBgchryReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("hyfb_djxh", domain.getHyfb_djxh());
        map.put("chr_swry_dm", domain.getChr_swry_dm());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10316HyChrBgsave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain PubGetClxx(PubGetClxxAppDomain domain) throws Exception {
        PubGetClxxReturnDomain returnDomain = new PubGetClxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ycsjq", domain.getYcsjq());
        map.put("ycsjz", domain.getYcsjz());
        map.put("code", "");
        map.put("mess", "");
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10108PubGetClxx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxClapCx(YbsxClapCxAppDomain domain) throws Exception {
        GrzxWdhyCxReturnDomain returnDomain = new GrzxWdhyCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("pczt", domain.getPczt());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10513PcxxList", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain YbsxClapSave(YbsxClapSaveAppDomain domain) throws Exception {
        YbsxClapSaveReturnDomain returnDomain = new YbsxClapSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("pc_djxh", domain.getPc_djxh());
        map.put("ycsj_q", domain.getYcsj_q());
        map.put("ycsj_z", domain.getYcsj_z());
        map.put("cfd", HstEncodeUtil.GBK2ISO(domain.getCfd()));
        map.put("mdd", HstEncodeUtil.GBK2ISO(domain.getMdd()));
        map.put("bz", HstEncodeUtil.GBK2ISO(domain.getBz()));
        map.put("sj_swry_dm", domain.getSj_swry_dm());
        map.put("cl_djxh", domain.getCl_djxh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10514ClapxxSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxKqNjxjcx(GrzxKqNjxjcxAppDomain domain) throws Exception {
        GrzxKqNjxjcxReturnDomain returnDomain = new GrzxKqNjxjcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10319KqNjxjcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxKqYdkqcx(GrzxKqYdkqcxAppDomain domain) throws Exception {
        GrzxKqYdkqcxReturnDomain returnDomain = new GrzxKqYdkqcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ssyf", domain.getSsyf());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10320KqYdkqcx", "dataList", map);
        BeanUtils.copyProperties((Object)returnDomain, map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain GrzxKqYdkqmxcx(GrzxKqYdkqmxcxAppDomain domain) throws Exception {
        GrzxKqYdkqmxcxReturnDomain returnDomain = new GrzxKqYdkqmxcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ssyf", domain.getSsyf());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10321Kqydkqmxcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxWcsqSave(WbsxWcsqSaveAppDomain domain) throws Exception {
        WbsxWcsqSaveReturnDomain returnDomain = new WbsxWcsqSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sqrq", domain.getSqrq());
        map.put("sqwcsjq", domain.getSqwcsjq());
        map.put("sqwcsjz", domain.getSqwcsjz());
        map.put("shiy", HstEncodeUtil.GBK2ISO(domain.getShiy()));
        map.put("wcdd", HstEncodeUtil.GBK2ISO(domain.getWcdd()));
        map.put("xtry", HstEncodeUtil.GBK2ISO(domain.getXtry()));
        map.put("bzsm", HstEncodeUtil.GBK2ISO(domain.getBzsm()));
        map.put("sfjd", domain.getSfjd());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10432WcsqSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setSxsqxh((String)map.get("sxsqxh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxWcysqxx(WbsxWcysqxxAppDomain domain) throws Exception {
        WbsxWcysqxxReturnDomain returnDomain = new WbsxWcysqxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", domain.getRows());
        map.put("page", domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10433Wcysqxx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxWcsqCxmx(WbsxWcsqCxmxAppDomain domain) throws Exception {
        WbsxWcsqCxmxReturnDomain returnDomain = new WbsxWcsqCxmxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfwh10434WcsqCxmx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        BeanUtils.copyProperties((Object)returnDomain, map);
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        HstEncodeUtil.conISO2GBK(returnDomain);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxWcsqQx(WbsxWcsqQxAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10435Wcsqqx", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrflxx(SqhdNsrflxxAppDomain domain) throws Exception {
        SqhdNsrflxxReturnDomain returnDomain = new SqhdNsrflxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10701SqhdNsrflxx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrflxxMd(SqhdNsrflxxMdAppDomain domain) throws Exception {
        SqhdNsrflxxMdReturnDomain returnDomain = new SqhdNsrflxxMdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("zdyflDjxh", domain.getZdyfl_djxh());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10702NsrflxxMc", "dataList", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrmdcx(SqhdNsrmdcxAppDomain domain) throws Exception {
        SqhdNsrmdcxReturnDomain returnDomain = new SqhdNsrmdcxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("zdyflDjxh", domain.getZdyfl_djxh());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("cxtj", HstEncodeUtil.GBK2ISO(domain.getCxtj()));
        } else {
            map.put("cxtj", domain.getCxtj());
        }
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10703Nsrmdcx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrdjxx(SqhdNsrdjxxAppDomain domain) throws Exception {
        SqhdNsrdjxxReturnDomain returnDomain = new SqhdNsrdjxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("djxh", domain.getDjxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10704Nsrdjxx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        if ("00".equals(code)) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrlxrxx(SqhdNsrlxrxxAppDomain domain) throws Exception {
        SqhdNsrlxrxxReturnDomain returnDomain = new SqhdNsrlxrxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("djxh", domain.getDjxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10705Nsrlxrxx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrfxyjxx(SqhdNsrfxyjxxAppDomain domain) throws Exception {
        SqhdNsrfxyjxxReturnDomain returnDomain = new SqhdNsrfxyjxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("djxh", domain.getDjxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10706Nsrfxyjxx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrblywxx(SqhdNsrblywxxAppDomain domain) throws Exception {
        SqhdNsrblywxxReturnDomain returnDomain = new SqhdNsrblywxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("djxh", domain.getDjxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10707Nsrblywxx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WzhhyHylistCx(WzhhyHylistCxAppDomain domain) throws Exception {
        String mess;
        WzhhyHylistCxReturnDomain returnDomain = new WzhhyHylistCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("wzhhy_djxh", domain.getWzhhy_djxh());
        map.put("sbsbm", domain.getSbsbm());
        map.put("sbxh", domain.getSbxh());
        map.put("rylb", domain.getRylb());
        map.put("login", domain.getLogin());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10515WzhhyListCx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            mess = HstEncodeUtil.ISO2GBK((String)map.get("mess"));
            returnDomain.setHyrq(HstEncodeUtil.ISO2GBK((String)map.get("hyrq")));
            returnDomain.setHyzt(HstEncodeUtil.ISO2GBK((String)map.get("hyzt")));
            returnDomain.setCbbm(HstEncodeUtil.ISO2GBK((String)map.get("cbbm")));
            returnDomain.setFzr(HstEncodeUtil.ISO2GBK((String)map.get("fzr")));
        } else {
            mess = (String)map.get("mess");
            returnDomain.setHyrq((String)map.get("hyrq"));
            returnDomain.setHyzt((String)map.get("hyzt"));
            returnDomain.setCbbm((String)map.get("cbbm"));
            returnDomain.setFzr((String)map.get("fzr"));
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WzhhyHymcCx(WzhhyHymcCxAppDomain domain) throws Exception {
        String mess;
        WzhhyHymcCxReturnDomain returnDomain = new WzhhyHymcCxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("rq", domain.getRq());
        map.put("sbsbm", domain.getSbsbm());
        map.put("sbxh", domain.getSbxh());
        map.put("rylb", domain.getRylb());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10516WzhhymcCx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            mess = HstEncodeUtil.ISO2GBK((String)map.get("mess"));
            returnDomain.setWymc_djxh(HstEncodeUtil.ISO2GBK((String)map.get("hymc_djxh")));
            returnDomain.setHymc(HstEncodeUtil.ISO2GBK((String)map.get("hymc")));
            returnDomain.setDjchy(HstEncodeUtil.ISO2GBK((String)map.get("djchy")));
        } else {
            mess = (String)map.get("mess");
            returnDomain.setWymc_djxh((String)map.get("hymc_djxh"));
            returnDomain.setHymc((String)map.get("hymc"));
            returnDomain.setDjchy((String)map.get("djchy"));
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WzhhyHylogin(WzhhyHyloginAppDomain domain) throws Exception {
        WzhhyHyloginReturnDomain returnDomain = new WzhhyHyloginReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("login", domain.getLogin());
        map.put("pwd", domain.getPwd());
        map.put("sbsbm", domain.getSbsbm());
        map.put("sbxh", domain.getSbxh());
        map.put("rylb", domain.getRylb());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10517WzhhyLogin", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WzhhyYtJhgb(WzhhyYtJhgbAppDomain domain) throws Exception {
        WzhhyYtJhgbReturnDomain returnDomain = new WzhhyYtJhgbReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("login", domain.getLogin());
        map.put("sbsbm", domain.getSbsbm());
        map.put("sbxh", domain.getSbxh());
        map.put("wzhhy_djxh", domain.getWzhhy_djxh());
        map.put("czlx", domain.getCzlx());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10518WzhhyYtjhgb", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WzhhyFjChk(WzhhyFjChkAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("sbsbm", domain.getSbsbm());
        map.put("sbxh", domain.getSbxh());
        map.put("wzhhy_djxh", domain.getWzhhy_djxh());
        map.put("rylb", domain.getRylb());
        map.put("xh", domain.getXh());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10519WzhhyFjchk", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain WzhhyFjLock(WzhhyFjLockAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("sbsbm", domain.getSbsbm());
        map.put("sbxh", domain.getSbxh());
        map.put("wzhhy_djxh", domain.getWzhhy_djxh());
        map.put("rylb", domain.getRylb());
        map.put("xh", domain.getXh());
        map.put("fjjm_pwd", domain.getFjjm_pwd());
        map.put("czbz", domain.getCzbz());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10520WzhhyFjLock", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WzhhyPzfjcl(WzhhyPzfjclAppDomain domain) throws Exception {
        WzhhyPzfjclReturnDomain returnDomain = new WzhhyPzfjclReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("login", domain.getLogin());
        map.put("rylb", domain.getRylb());
        map.put("wzhhy_djxh", domain.getWzhhy_djxh());
        map.put("xh", domain.getXh());
        map.put("czlx", domain.getCzlx());
        map.put("pzfjxh", domain.getPzfjxh());
        map.put("pzfjmc", domain.getPzfjmc());
        map.put("pzfjlx", domain.getPzfjlx());
        map.put("pzfjname", domain.getPzfjname());
        map.put("pzfjurl", domain.getPzfjurl());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfwh10521Wzhhypzfjcl", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setPzfjxh((String)map.get("pzfjxh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjMLGetList(ZhdjMLGetListAppDomain domain) throws Exception {
        ZhdjMLGetListReturnDomain returnDomain = new ZhdjMLGetListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10801DjmlGetList", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjMLUpdate(ZhdjMLUpdateAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("mldm", domain.getMldm());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10802Djmlupdate", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjZzjgGetJjg(ZhdjZzjgGetJjgAppDomain domain) throws Exception {
        ZhdjZzjgGetJjgReturnDomain returnDomain = new ZhdjZzjgGetJjgReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cx_swjg_dm", domain.getCx_swjg_dm());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10803DjZzjgGetJjg", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjZzjgGetDzb(ZhdjZzjgGetDzbAppDomain domain) throws Exception {
        ZhdjZzjgGetDzbReturnDomain returnDomain = new ZhdjZzjgGetDzbReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cx_swjg_dm", domain.getCx_swjg_dm());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10804DjZzjgGetDzb", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjZzjgGetQz(ZhdjZzjgGetQzAppDomain domain) throws Exception {
        ZhdjZzjgGetQzReturnDomain returnDomain = new ZhdjZzjgGetQzReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cx_swjg_dm", domain.getCx_swjg_dm());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10805DjZzjgGetQz", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjZzjgGetDymd(ZhdjZzjgGetDymdAppDomain domain) throws Exception {
        ZhdjZzjgGetDymdReturnDomain returnDomain = new ZhdjZzjgGetDymdReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("dzb_dm", domain.getDzb_dm());
        map.put("qz_dm", domain.getQz_dm());
        map.put("cxlb", domain.getCxlb());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10806DjzzgGetDymd", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjGrGetJbxx(ZhdjGrGetJbxxAppDomain domain) throws Exception {
        ZhdjGrGetJbxxReturnDomain returnDomain = new ZhdjGrGetJbxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10807DjgrGetJbxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjGrGetDyjf(ZhdjGrGetDyjfAppDomain domain) throws Exception {
        ZhdjGrGetDyjfReturnDomain returnDomain = new ZhdjGrGetDyjfReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ssnd", domain.getSsnd());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10808DjGrGetDyjf", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        returnDomain.setJbf((String)map.get("jbf"));
        returnDomain.setXff((String)map.get("xff"));
        returnDomain.setKf((String)map.get("kf"));
        returnDomain.setZjf((String)map.get("zjf"));
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjGrGetGlqx(ZhdjGrGetGlqxAppDomain domain) throws Exception {
        ZhdjGrGetGlqxReturnDomain returnDomain = new ZhdjGrGetGlqxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10809DjGrGetGlqx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjGrSaveGlqx(ZhdjGrSaveGlqxAppDomain domain) throws Exception {
        ZhdjGrSaveGlqxReturnDomain returnDomain = new ZhdjGrSaveGlqxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("jgzbbz", domain.getJgzbbz());
        map.put("jgzbdm", domain.getJgzbdm());
        map.put("glpwd", domain.getGlpwd());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10810DjGrSaveGlqx", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjTwxxGetList(ZhdjTwxxGetListAppDomain domain) throws Exception {
        ZhdjTwxxGetListReturnDomain returnDomain = new ZhdjTwxxGetListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("zb_dm", domain.getZb_dm());
        map.put("rylb", domain.getRylb());
        map.put("swjg_dm", domain.getSwjg_dm());
        map.put("gnmk_dm", domain.getGnmk_dm());
        map.put("cxlbfl", domain.getCxlbfl());
        map.put("parm", domain.getParm());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10811DjtwGetList", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTwxxGetList_ssgl(ZhdjTwxxGetListAppDomain domain) throws Exception {
        ZhdjTwxxGetListReturnDomain returnDomain = new ZhdjTwxxGetListReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("zb_dm", domain.getZb_dm());
        map.put("rylb", domain.getRylb());
        map.put("swjg_dm", domain.getSwjg_dm());
        map.put("gnmk_dm", domain.getGnmk_dm());
        map.put("cxlbfl", domain.getCxlbfl());
        map.put("parm", HstEncodeUtil.GBK2ISO(domain.getParm()));
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10811DjtwGetListSsgl", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTwxxGetTj(ZhdjTwxxGetTjAppDomain domain) throws Exception {
        ZhdjTwxxGetTjReturnDomain returnDomain = new ZhdjTwxxGetTjReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ywid", domain.getYwid());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108012DjtwGetTj", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTwxxGetHf(ZhdjTwxxGetHfAppDomain domain) throws Exception {
        ZhdjTwxxGetHfReturnDomain returnDomain = new ZhdjTwxxGetHfReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ywid", domain.getYwid());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108013jtwGetHf", "dataList", map);
        List result = (List)map.get("dataList");
        HashMap<String, ZhdjTwxxGetHfDomain> resultMap = new HashMap<String, ZhdjTwxxGetHfDomain>();
        ArrayList<ZhdjTwxxGetHfDomain> dataList = new ArrayList<ZhdjTwxxGetHfDomain>();
        for (ZhdjTwxxGetHfDataDomain tmp : result) {
            ZhdjTwxxGetHfSubDomain sub;
            ZhdjTwxxGetHfDomain data;
            if (resultMap.containsKey(tmp.getYwid())) {
                data = (ZhdjTwxxGetHfDomain)resultMap.get(tmp.getYwid());
                sub = new ZhdjTwxxGetHfSubDomain();
                BeanUtils.copyProperties((Object)sub, (Object)tmp);
                data.getSubList().add(sub);
                continue;
            }
            data = new ZhdjTwxxGetHfDomain();
            data.setDzrlist(tmp.getDzrlist());
            data.setYwid(tmp.getYwid());
            sub = new ZhdjTwxxGetHfSubDomain();
            BeanUtils.copyProperties((Object)sub, (Object)tmp);
            data.getSubList().add(sub);
            resultMap.put(tmp.getYwid(), data);
            dataList.add(data);
        }
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTwxxSaveHf(ZhdjTwxxSaveHfAppDomain domain) throws Exception {
        ZhdjTwxxSaveHfReturnDomain returnDomain = new ZhdjTwxxSaveHfReturnDomain();
        QyhZhdjTwxxLog log = new QyhZhdjTwxxLog();
        BeanUtils.copyProperties((Object)log, (Object)domain);
        log.setGjnrxx(domain.getPlhfnr());
        log.setCzy_dm(domain.getSwrydm());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        log.setDatabaseUsername(databaseUsername);
        this.sqlMapClientTemplate.insert("insertQyhZhdjTwxxLog", log);
        String log_xh = log.getLog_xh();
        QyhZhdjTwxxLogYwbw ywbw = new QyhZhdjTwxxLogYwbw();
        ywbw.setLog_xh(log_xh);
        ywbw.setDatabaseUsername(databaseUsername);
        ywbw.setYwbw(new Gson().toJson((Object)domain));
        this.sqlMapClientTemplate.insert("insertQyhZhdjTwxxLogYwbw", ywbw);
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("log_xh", log_xh);
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw108014DjTwxSaveHf", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setLog_xh(log_xh);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTwxxGetMx_ssgl(ZhdjTwxxGetMxAppDomain domain) throws Exception {
        ZhdjTwxxGetMxReturnDomain returnDomain = new ZhdjTwxxGetMxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ywid", domain.getYwid());
        map.put("gnmk_dm", domain.getGnmk_dm());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108015jtwGetMx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjTwxxGetMx(ZhdjTwxxGetMxAppDomain domain) throws Exception {
        ZhdjTwxxGetMxReturnDomain returnDomain = new ZhdjTwxxGetMxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ywid", domain.getYwid());
        map.put("gnmk_dm", domain.getGnmk_dm());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108015jtwGetMx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    public TaxCommonReturnDomain ZhdjTwxxSave(ZhdjTwxxSaveAppDomain domain) throws Exception {
        ZhdjTwxxSaveReturnDomain returnDomain = new ZhdjTwxxSaveReturnDomain();
        QyhZhdjTwxxLog log = new QyhZhdjTwxxLog();
        log.setYwid(domain.getYwid());
        log.setGnmk_dm(domain.getGnmk_dm());
        log.setTwxxlx_dm(domain.getTwxxlx_dm());
        log.setCzy_dm(domain.getSwrydm());
        if (StringUtils.isBlank((String)domain.getYwid())) {
            log.setCzlx_dm("201");
        } else {
            log.setCzlx_dm("202");
        }
        log.setCzfs("2");
        log.setGjnrxx("");
        log.setCzy_dm(domain.getSwrydm());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        log.setDatabaseUsername(databaseUsername);
        this.sqlMapClientTemplate.insert("insertQyhZhdjTwxxLog", log);
        String log_xh = log.getLog_xh();
        QyhZhdjTwxxLogYwbw ywbw = new QyhZhdjTwxxLogYwbw();
        ywbw.setLog_xh(log_xh);
        ywbw.setDatabaseUsername(databaseUsername);
        ywbw.setYwbw(new Gson().toJson((Object)domain));
        this.sqlMapClientTemplate.insert("insertQyhZhdjTwxxLogYwbw", ywbw);
        String pclXh = HstToolsUtil.getSequence(this.sqlMapClientTemplate.getDataSource().getConnection(), "SEQ_PCL_XH");
        LsbZhdjTwxxSave lsb = new LsbZhdjTwxxSave();
        BeanUtils.copyProperties((Object)lsb, (Object)domain);
        lsb.setPcl_xh(pclXh);
        lsb.setDatabaseUsername(databaseUsername);
        this.sqlMapClientTemplate.insert("insertLsbZhdjTwxxSave", lsb);
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("pcl_xh", pclXh);
        map.put("log_xh", log_xh);
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw108016DjTwxSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        String ywid = (String)map.get("ywid");
        returnDomain.setYwid(ywid);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTwxxDoSave(ZhdjTwxxDoSaveAppDomain domain) throws Exception {
        ZhdjTwxxDoSaveReturnDomain returnDomain = new ZhdjTwxxDoSaveReturnDomain();
        QyhZhdjTwxxLog log = new QyhZhdjTwxxLog();
        BeanUtils.copyProperties((Object)log, (Object)domain);
        log.setCzy_dm(domain.getSwrydm());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        log.setDatabaseUsername(databaseUsername);
        this.sqlMapClientTemplate.insert("insertQyhZhdjTwxxLog", log);
        String log_xh = log.getLog_xh();
        QyhZhdjTwxxLogYwbw ywbw = new QyhZhdjTwxxLogYwbw();
        ywbw.setLog_xh(log_xh);
        ywbw.setDatabaseUsername(databaseUsername);
        ywbw.setYwbw(new Gson().toJson((Object)domain));
        this.sqlMapClientTemplate.insert("insertQyhZhdjTwxxLogYwbw", ywbw);
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("log_xh", log_xh);
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw108017DjTwxDoSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setLog_xh(log_xh);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTwxxGetRy(ZhdjTwxxGetRyAppDomain domain) throws Exception {
        ZhdjTwxxGetRyReturnDomain returnDomain = new ZhdjTwxxGetRyReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ywid", domain.getYwid());
        map.put("gnmk_dm", domain.getGnmk_dm());
        map.put("ryxxfl", domain.getRyxxfl());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108018jtwGetRy", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjZxcsGetTj(ZhdjZxcsGetTjAppDomain domain) throws Exception {
        ZhdjZxcsGetTjReturnDomain returnDomain = new ZhdjZxcsGetTjReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("rq", domain.getRq());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108021DjcsGetTj", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if ("00".equals(code) && dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjZxcsGetCstm(ZhdjZxcsGetCstmAppDomain domain) throws Exception {
        ZhdjZxcsGetCstmReturnDomain returnDomain = new ZhdjZxcsGetCstmReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("ndxs_q", domain.getNdxs_q());
        map.put("ndxs_z", domain.getNdxs_z());
        map.put("ywfl", domain.getYwfl());
        map.put("tmlx", domain.getTmlx());
        map.put("sftcdr", domain.getSftcdr());
        map.put("sftcls", domain.getSftcls());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108022DjcsGetCstm", "dataList", map);
        List result = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        ArrayList<ZhdjZxcsGetCstmDomain> dataList = new ArrayList<ZhdjZxcsGetCstmDomain>();
        if (result.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, result.get(0));
            for (ZhdjZxcsGetCstmDataDomain data : result) {
                ZhdjZxcsGetCstmDomain dom = new ZhdjZxcsGetCstmDomain();
                BeanUtils.copyProperties((Object)dom, (Object)data);
                dataList.add(dom);
            }
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjZxcsSaveCstm(ZhdjZxcsSaveCstmAppDomain domain) throws Exception {
        ZhdjZxcsSaveCstmReturnDomain returnDomain = new ZhdjZxcsSaveCstmReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("tmwh_xh", domain.getTmwh_xh());
        map.put("daxx", domain.getDaxx());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108023DjcsSaveCstm", "dataList", map);
        ArrayList dataList = new ArrayList();
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        if (dataList.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, dataList.get(0));
        }
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjWjGetMx(ZhdjWjGetMxAppDomain domain) throws Exception {
        ZhdjWjGetMxReturnDomain returnDomain = new ZhdjWjGetMxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("wjdctp_xh", domain.getWjdctp_xh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108024DjwjGetMx", "dataList", map);
        List result = (List)map.get("dataList");
        HashMap<String, ZhdjWjGetMxDomain> resultMap = new HashMap<String, ZhdjWjGetMxDomain>();
        ArrayList<ZhdjWjGetMxDomain> dataList = new ArrayList<ZhdjWjGetMxDomain>();
        if (result.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, result.get(0));
        }
        for (ZhdjWjGetMxDataDomain tmp : result) {
            ZhdjWjGetMxSubDomain sub;
            ZhdjWjGetMxDomain data;
            if (resultMap.containsKey(tmp.getWtxh())) {
                data = (ZhdjWjGetMxDomain)resultMap.get(tmp.getWtxh());
                sub = new ZhdjWjGetMxSubDomain();
                BeanUtils.copyProperties((Object)sub, (Object)tmp);
                data.getSubList().add(sub);
                continue;
            }
            data = new ZhdjWjGetMxDomain();
            BeanUtils.copyProperties((Object)data, (Object)tmp);
            sub = new ZhdjWjGetMxSubDomain();
            BeanUtils.copyProperties((Object)sub, (Object)tmp);
            data.getSubList().add(sub);
            resultMap.put(tmp.getWtxh(), data);
            dataList.add(data);
        }
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjWjSave(ZhdjWjSaveAppDomain domain) throws Exception {
        ZhdjWjSaveReturnDomain returnDomain = new ZhdjWjSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("wjdctp_xh", domain.getWjdctp_xh());
        map.put("wjdccj_xh", domain.getWjdccj_xh());
        map.put("yjjy", domain.getYjjy());
        String databaseUsername = WebConstants.HST_PROP_MAP.get("hst.SCHEMA_TM");
        String pclXh = HstToolsUtil.getSequence(this.sqlMapClientTemplate.getDataSource().getConnection(), "SEQ_PCL_XH");
        for (ZhdjWjSaveDomain dom : domain.getDataList()) {
            for (ZhdjWjSaveSubDomain sub : dom.getSubList()) {
                LsbZhdjWjcj bo = new LsbZhdjWjcj();
                bo.setPcl_xh(pclXh);
                bo.setDatabaseUsername(databaseUsername);
                bo.setWtxh(dom.getWtxh());
                bo.setDaxxxh(sub.getDaxxxh());
                bo.setNrblxx(sub.getBrnrblxx());
                bo.setWjdctp_xh(domain.getWjdctp_xh());
                this.sqlMapClientTemplate.insert("insertLsbZhdjWjcj", bo);
            }
        }
        map.put("pcl_xh", pclXh);
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw108025DjwjSave", map);
        List cfr_ignored_0 = (List)map.get("dataList");
        String code = (String)map.get("code");
        String rtnCjxh = (String)map.get("rtnCjxh");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setWjdccj_xh(rtnCjxh);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTpGetMx(ZhdjTpGetMxAppDomain domain) throws Exception {
        ZhdjTpGetMxReturnDomain returnDomain = new ZhdjTpGetMxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("wjdctp_xh", domain.getWjdctp_xh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108026DjTpgetMx", "dataList", map);
        List result = (List)map.get("dataList");
        ArrayList<ZhdjTpGetMxDomain> dataList = new ArrayList<ZhdjTpGetMxDomain>();
        if (result.size() > 0) {
            BeanUtils.copyProperties((Object)returnDomain, result.get(0));
        }
        for (ZhdjTpGetMxDataDomain tmp : result) {
            ZhdjTpGetMxDomain dom = new ZhdjTpGetMxDomain();
            BeanUtils.copyProperties((Object)dom, (Object)tmp);
            dataList.add(dom);
        }
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTpSave(ZhdjTpSaveAppDomain domain) throws Exception {
        ZhdjTpSaveReturnDomain returnDomain = new ZhdjTpSaveReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("wjdctp_xh", domain.getWjdctp_xh());
        map.put("tp_zpbh", HstEncodeUtil.GBK2ISO(domain.getTp_zpbh()));
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw108027DjTpSave", map);
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        String tpdj_xh = (String)map.get("tpdj_xh");
        returnDomain.setTpdj_xh(tpdj_xh);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain ZhdjTpGetTj(ZhdjTpGetTjAppDomain domain) throws Exception {
        ZhdjTpGetTjReturnDomain returnDomain = new ZhdjTpGetTjReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("wjdctp_xh", domain.getWjdctp_xh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw108028DjTpTj", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "";
        mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED, value="myTransactionManager_Zhdj")
    public TaxCommonReturnDomain ZhdjHdGetHdlx(ZhdjHdGetHdlxAppDomain domain) throws Exception {
        ZhdjHdGetHdlxReturnDomain returnDomain = new ZhdjHdGetHdlxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("fqzz_dm", domain.getFqzz_dm());
        map.put("zslx", domain.getZslx());
        map.put("jflx", domain.getJflx());
        this.zhdjSqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10829DjGetHdlx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrxxmx(SqhdNsrxxmxAppDomain domain) throws Exception {
        SqhdNsrxxmxReturnDomain returnDomain = new SqhdNsrxxmxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("djxh", domain.getDjxh());
        map.put("bsydj_xh", domain.getBsydj_xh());
        map.put("rows", StringUtils.isBlank((String)domain.getRows()) ? "10" : domain.getRows());
        map.put("page", StringUtils.isBlank((String)domain.getPage()) ? "1" : domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10708NsrxxMx", "dataList", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        List dataList = (List)map.get("dataList");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain SqhdNsrxxfs(SqhdNsrxxfsAppDomain domain) throws Exception {
        SqhdNsrxxfsReturnDomain returnDomain = new SqhdNsrxxfsReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("djxh", domain.getDjxh());
        map.put("bsydj_xh", domain.getBsydj_xh());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("fsnr", HstEncodeUtil.GBK2ISO(domain.getFsnr()));
        } else {
            map.put("fsnr", domain.getFsnr());
        }
        map.put("xxlx", domain.getXxlx());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10709NsrxxFs", map);
        String cfr_ignored_0 = (String)map.get("code");
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            HstEncodeUtil.ISO2GBK((String)map.get("mess"));
        } else {
            String cfr_ignored_1 = (String)map.get("mess");
        }
        returnDomain.setXxdj_xh((String)map.get("xxdj_xh"));
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WzhhyHymcCx2(WzhhyHymcCx2AppDomain domain) throws Exception {
        String mess;
        WzhhyHymcCx2ReturnDomain returnDomain = new WzhhyHymcCx2ReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("rq", domain.getRq());
        map.put("sbsbm", domain.getSbsbm());
        map.put("sbxh", domain.getSbxh());
        map.put("rylb", domain.getRylb());
        map.put("hymcDjxhCX", domain.getHymc_djxh());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10522Wzhhymccx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            mess = HstEncodeUtil.ISO2GBK((String)map.get("mess"));
            returnDomain.setHymc_djxh(HstEncodeUtil.ISO2GBK((String)map.get("hymcDjxh")));
            returnDomain.setHymc(HstEncodeUtil.ISO2GBK((String)map.get("hymc")));
            returnDomain.setDjchy(HstEncodeUtil.ISO2GBK((String)map.get("djchy")));
        } else {
            mess = (String)map.get("mess");
            returnDomain.setHymc_djxh((String)map.get("hymcDjxh"));
            returnDomain.setHymc((String)map.get("hymc"));
            returnDomain.setDjchy((String)map.get("djchy"));
        }
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WzhhyHylistCx2(WzhhyHylistCx2AppDomain domain) throws Exception {
        WzhhyHylistCx2ReturnDomain returnDomain = new WzhhyHylistCx2ReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("rq", domain.getRq());
        map.put("sbsbm", domain.getSbsbm());
        map.put("sbxh", domain.getSbxh());
        map.put("rylb", domain.getRylb());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10523WzhhyListCx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setDataList(dataList);
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxYcsqSavePj(WbsxYcsqSavePjAppDomain domain) throws Exception {
        TaxCommonReturnDomain returnDomain = new TaxCommonReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("sxsqxh", domain.getSxsqxh());
        map.put("fwtd", domain.getFwtd());
        map.put("cczdl", domain.getCczdl());
        map.put("ckzjd", domain.getCkzjd());
        map.put("jsaqx", domain.getJsaqx());
        map.put("zhpj", domain.getZhpj());
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw104151SavePj", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxYyfwThyy(WbsxYyfwThyyAppDomain domain) throws Exception {
        WbsxYyfwThyyReturnDomain returnDomain = new WbsxYyfwThyyReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("yyfwxh", domain.getYyfwxh());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("thyy", HstEncodeUtil.GBK2ISO(domain.getThyy()));
        } else {
            map.put("thyy", domain.getThyy());
        }
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10438YyfwThyy", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxYyfwCxLsxx(WbsxYyfwCxLsxxAppDomain domain) throws Exception {
        WbsxYyfwCxLsxxReturnDomain returnDomain = new WbsxYyfwCxLsxxReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("cxrq", domain.getCxrq());
        map.put("rows", domain.getRows());
        map.put("page", domain.getPage());
        this.sqlMapClientTemplate.queryForObjectByCurr("pWebjkWxfw10439YyfwLsxx", "dataList", map);
        List dataList = (List)map.get("dataList");
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        returnDomain.setDataList(dataList);
        return returnDomain;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public TaxCommonReturnDomain WbsxYyfwSwrypj(WbsxYyfwSwrypjAppDomain domain) throws Exception {
        WbsxYyfwSwrypjReturnDomain returnDomain = new WbsxYyfwSwrypjReturnDomain();
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("swjgdm", domain.getSwjgdm());
        map.put("swrydm", domain.getSwrydm());
        map.put("yyfwxh", domain.getYyfwxh());
        map.put("swzypj_zysy", domain.getSwzypj_zysy());
        map.put("swzypj_gtscd", domain.getSwzypj_gtscd());
        map.put("yyfwxh", domain.getYyfwxh());
        if ("ISO".equals(WebConstants.DATABASE_ENCODE)) {
            map.put("slqkms", HstEncodeUtil.GBK2ISO(domain.getSlqkms()));
        } else {
            map.put("slqkms", domain.getSlqkms());
        }
        this.sqlMapClientTemplate.queryForObject("pWebjkWxfw10440YyfwSwryPj", map);
        String code = (String)map.get("code");
        String mess = "ISO".equals(WebConstants.DATABASE_ENCODE) ? HstEncodeUtil.ISO2GBK((String)map.get("mess")) : (String)map.get("mess");
        returnDomain.setCode(code);
        returnDomain.setMess(mess);
        return returnDomain;
    }
}
