package com.espeed.action;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import com.espeed.centre.pojo.CentreYxyedmNewcustomer;
import com.espeed.centre.pojo.CentreYxyedmOldcustomer;
import com.espeed.centre.pojo.YxyUserInfo;
import com.espeed.log.LogClass;
import com.espeed.pojo.YxyNoshieldEmail;
import com.espeed.pojo.YxySendMailMaster;
import com.espeed.pojo.YxySendSmtpInfo;
import com.espeed.pojo.YxySendSysFilter;
import com.espeed.pojo.YxyShieldDomain;
import com.espeed.pojo.YxyUserAddress;
import com.espeed.pojo.YxyUserSet;
import com.espeed.service.YxyAddressManageService;
import com.espeed.service.YxyContextSetService;
import com.espeed.service.YxyCustomerService;
import com.espeed.service.YxyNoshieldEmailService;
import com.espeed.service.YxyReadingInfoService;
import com.espeed.service.YxySendFilterAddressService;
import com.espeed.service.YxySendMailService;
import com.espeed.service.YxySendSysFilterService;
import com.espeed.service.YxyShieldDomainService;
import com.espeed.service.YxySysParamaterService;
import com.espeed.service.YxyUnsubscribeInfoService;
import com.espeed.service.YxyUserInfoService;
import com.espeed.tool.ConfigPath;
import com.espeed.tool.DateFormat;
import com.espeed.tool.DomParseXml;
import com.espeed.tool.GetRandom;
import com.espeed.webmail.pojo.YxyCustomerEmail;
import com.opensymphony.xwork2.ActionContext;
 
/**
 * 程序名称:    	EspeedMail_时速邮箱
 * 程序版本:    	V1.0
 * 作    者:    	深圳市科飞时速网络技术有限公司(0755-88843776)
 * 版权所有:    	深圳市科飞时速网络技术有限公司
 * 技术支持:    	Tech@21gmail.com
 * 单元名称:    	邮件发送Action
 * 开始时间:    	2013.10.22
 * 程 序 员:    	谢勇 
 * 最后修改:    
 * 备    注:		邮件处理(营销)    
 */
public class YxySendMailAction extends BaseAction{
	private static final long serialVersionUID = 1L;
	public final String emailreg=ConfigPath.getEmailYZ();//"[a-zA-Z0-9.-\\\\-_]{1,30}@[a-zA-Z0-9.-]{1,40}\\.(?!gif|jpg|png|pdf)[a-zA-Z]{2,10}";

	/**判断是否有警示或者过滤(系统)*/
	public String findWarnString(){
		listResult.add("1");//当发送的邮件不包括警告内容和过滤内容，就返回1正常发送
		try {
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();			
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid=user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			//查询所有过滤字符(系统级的)
			List<YxySendSysFilter> filterlist=yxysendsysfilterservice.findAllFilterStr();
			//警示字符
			String warnString="";
			//过滤字符
			String fiterString="";
			
			//当数据库存在多个警告字符和过滤字符时，要进行截取
			String str1 = "";//过滤字符
			String str2 = "";//警告字符
			
			//循环判断
			for(int i=0;i<filterlist.size();i++){
				warnString=filterlist.get(i).getWarnstring();//警示字符
				fiterString=filterlist.get(i).getFilterstring();//过滤字符
			
				//过滤字符
				if(fiterString!=null&&!"".equals(fiterString)){
					if((title.indexOf(fiterString)!=-1||context.indexOf(fiterString)!=-1)){
						str1 += fiterString + ";";
						/*listResult.add("-2");
						listResult.add(fiterString);
						return "filter";*/
					}
				}
				//警告字符
				if(warnString!=null&&!warnString.equals("")){
					if((title.indexOf(warnString)!=-1||context.indexOf(warnString)!=-1)){
						str2 += warnString + ";";
						/*listResult.add("-1");
						listResult.add(warnString);
						return "filter";*/
					}
				}
			}
			//1.当过滤字符不为"",警告字符为""
			if(!str1.equals("") && str2.equals(""))
			{
				listResult.set(0, "-2");
				listResult.add(str1);
			}
			//2.当警告字符不为"",过滤字符为""
			if(!str2.equals("") && str1.equals("")){
				listResult.set(0, "-1");
				listResult.add(str2);
			}
			//3.当过滤字符和警告字符都不为""
			if(!str2.equals("") && !str1.equals("")){
				listResult.set(0, "-2");
				listResult.add(str1);
			}
		} catch (Exception e) {
			listResult.set(0, "0");
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return "filter";
	}
	
	/**导入地址*/
	public String importAddress(){
		try{
			//定义反回值
			importmap.put("result",0);//导入是否成功
			importmap.put("success",0);//成功量
			importmap.put("tolnum",0);//文件总量
			importmap.put("unnum",0);//退订量
			importmap.put("fcnum",0);//文件重复
			importmap.put("scnum",0);//系统重复
			importmap.put("nonum",0);//不合法量
			importmap.put("crmnum",0);//crm库重复
			importmap.put("selfnum",0);//本地库重复
			importmap.put("filtercustomnum",0);//用户自定义过滤地址量
			importmap.put("filtersysnum",0);//系统屏蔽量
			
			importaddress.put("unaddr","");//退订地址
			importaddress.put("fcaddr","");//文件重复地址
			importaddress.put("scaddr","");//系统重复地址
			importaddress.put("noaddr","");//不合法地址
			importaddress.put("crmaddr","");//crm库重复
			importaddress.put("selfaddr","");//本地库重复
			importaddress.put("filtercustom","");//用户自定义过滤地址
			importaddress.put("filtersys","");//系统屏蔽
			
			String unaddr="";//退订地址
			String fcaddr="";//文件重复地址
			String scaddr="";//系统重复地址
			String noaddr="";//不合法地址
			String filtercustom="";//用户自定义过滤地址
			String filtersys="";//系统屏蔽地址
			String crmaddr="";//crm库重复
			String selfaddr="";//本地库重复
			
			//变量定义
			int filelinenum=0;//文本行数
			String filterstr="";//过滤字符
			String filetype="";//文件类型
			int filemaxline=0;//导入地址最大行数
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();	
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid=user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			
			//清除之前的sess
			sess.remove("sendaddress");
			
			//时间定义
			SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String nowdate=df.format(new Date());
			
			//读取上传文件路径
			String addressFilePath=yxyaddr.getPath();
			
			//判断文件格式是否正确
			int i=addrfilename.lastIndexOf(".");
			filetype=addrfilename.substring(i + 1);
			
			//如是不是txt与xls类型文件则无法导入
			if(!"txt".equals(filetype)&&!"xls".equals(filetype)&&!"xlsx".equals(filetype)){
				importmap.put("result",-1);//不支持的文件类型
				return "map";
			}
			
			//导入地址最大行数
			filemaxline=ConfigPath.getFilemaxline();
			//文件是否为空判断
			if("txt".equals(filetype)){
				filelinenum=DomParseXml.getTxtLineNum(addressFilePath);//txt文件条数
				importmap.put("tolnum",filelinenum-1);//文件条数
				if(filelinenum<=1){
					importmap.put("result",-2);//文件无任何数据
					return "map";
				}else if(filelinenum>filemaxline){
					importmap.put("result",-3);
					importmap.put("scnum",filemaxline);
					return "map";
				}
			}else if("xls".equals(filetype)){
				InputStream in=new FileInputStream(new File(addressFilePath));
				HSSFWorkbook wb = new HSSFWorkbook(in);
				HSSFSheet sheet = wb.getSheetAt(0);//读取第一个工作表
				filelinenum=sheet.getLastRowNum() + 1;//xls文件条数
				importmap.put("tolnum",filelinenum-1);//文件条数
			     //判断是否有数据
			    if(filelinenum<=1){
			    	importmap.put("result",-2);//文件无任何数据
			    	return "map";
			    }else if(filelinenum>filemaxline){
			    	importmap.put("result",-3);
			    	importmap.put("scnum",filemaxline);
			    	return "map";
				}	
			}else if("xlsx".equals(filetype)){
				InputStream in=new FileInputStream(new File(addressFilePath));
				XSSFWorkbook workbook = new XSSFWorkbook(in);
				XSSFSheet sheet = workbook.getSheetAt(0);
				filelinenum=sheet.getLastRowNum() + 1;//xls文件条数
				importmap.put("tolnum",filelinenum-1);//文件条数
			    //判断是否有数据
			    if(filelinenum<=1){
			    	importmap.put("result",-2);//文件无任何数据
			    	return "map";
			    }else if(filelinenum>filemaxline){
			    	importmap.put("result",-3);
			    	importmap.put("scnum",filemaxline);
			    	return "map";
				}			     
			}
			
			//查询用户个人设置
			List<YxyUserSet> yxyuserset=yxysendmailservice.findUserSet(loginid,domain);
			if(yxyuserset.size()>0){//有用户设置
				//用户过滤的字符
				filterstr=yxyuserset.get(0).getUser_set_fiterStr();
			}
			//查询用户地址库
			List<Object> alllist = new ArrayList<Object>();
			if(user.getUser_type() == 1){//营销邮用户有地址库，易外销用户没有地址库
				alllist=yxyaddressmanageservice.findUserAllAddress(loginid,domain);
			}
			//查询用户退订地址
			List<Object> unalllist=yxyunsubscribeinfoservice.findAllUnEmali(loginid,domain);
			//可发地址对象
			List<YxyUserAddress> sendAddrList = new ArrayList<YxyUserAddress>();
			//查询屏蔽的域名
			List<YxyShieldDomain> shielddoamin=shielddomainservice.findAllList();
			//查询不屏蔽的邮件地址
			List<YxyNoshieldEmail> noshieldemail=noshieldemailservice.findAllList();
			//文本文件的地址集合
			List<String> fileEmail=new ArrayList<String>();

			//文件类型不同处理方案
			if("txt".equals(filetype)){
				//解析文件
				String tmpLineVal;
				String encoding = "";
				BufferedInputStream bin = new BufferedInputStream(new FileInputStream(addressFilePath));
				int p = (bin.read() << 8) + bin.read();
				switch (p) {    
	              case 0xefbb:    
	            	  encoding = "UTF-8";    
	                  break;    
	              case 0xfffe:    
	            	  encoding = "Unicode";    
	                  break;    
	              case 0xfeff:    
	            	  encoding = "UTF-16BE";    
	                  break;    
	              default:    
	            	  encoding = "GBK";    
				} 
				InputStreamReader in1 = new InputStreamReader(new FileInputStream(addressFilePath), encoding);
				BufferedReader bufread1 = new BufferedReader(in1);
				String line_record ="";
				int next=0;
				while((tmpLineVal = bufread1.readLine())!=null){
					next++;
					if(next==1){
						continue;
					}
					// 解析每一条记录返回结果
					line_record = tmpLineVal;//raf.readLine();
					if(line_record!=null&&!line_record.equals("")){
						//去掉空格
						line_record =line_record.trim();
						line_record = line_record.replace("<", "&lt;");
						//该行做判断(地址@后面只能有两个点且只能是数字字母)
						String yz1[]=line_record.split("@");
						//字符长度不能大于60
						if(line_record.length()>60){
							noaddr+=line_record+",";
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
							continue;
						}else if(yz1.length!=2){//最多两个.
							noaddr+=line_record+",";
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
							continue;
						}
						//以字母结尾
						byte b=yz1[1].getBytes()[yz1[1].length()-1];
						if((b>=97&&b<=122)||(b>=65&&b<=90)){
							//System.out.println(yz1[1]);
						}else{
							noaddr+=line_record+",";
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
							continue;
						}
						Pattern yz = Pattern.compile(emailreg);
						Matcher m = yz.matcher(line_record);
						line_record=line_record.replaceAll(" ", "");
						if(m.matches()){//是正确的
							//易外销用户才验证crm库
							if(user.getUser_type() == 0){
								//判断是不是在crm库中
								int exits=yxyaddressmanageservice.findcrmisexits(user.getCompany_id(),line_record);
								if(exits==2){
									crmaddr+=line_record+",";
									int crmnum=importmap.get("crmnum")+1;
									importmap.put("crmnum",crmnum);//crm库重复
									continue;
								}
							}
							//验证地址
							int parseresult=parseRecord(line_record,alllist,unalllist,shielddoamin,noshieldemail,fileEmail,filterstr);
							fileEmail.add(line_record);
							//可发
							if(parseresult==0){
								int success=importmap.get("success")+1;
								importmap.put("success",success);//成功量
								//加入对象
								YxyUserAddress addr = new YxyUserAddress();  
								addr.setUser_addr_email(line_record);//地址
								addr.setUser_addr_type_id(typeid);//所属类别ID
								addr.setUser_addr_name("");//姓名
								addr.setUser_addr_add_date(nowdate);//建立时间
								addr.setUser_loginid(loginid);//用户账号
								addr.setUser_domain(domain);//用户所属域名
								addr.setUser_addr_sex("男");//性别
								sendAddrList.add(addr);
							}else if(parseresult>0){//本地库重复
								selfaddr+=line_record+",";
								int selfnum=importmap.get("selfnum")+1;
								importmap.put("selfnum",selfnum);//本地库重复
							}else if(parseresult==-1){//文件重复
								fcaddr+=line_record+",";
								int fcnum=importmap.get("fcnum")+1;
								importmap.put("fcnum",fcnum);//文件重复
							}else if(parseresult==-2){//退订
								unaddr+=line_record+",";
								int unnum=importmap.get("unnum")+1;
								importmap.put("unnum",unnum);//退订
							}else if(parseresult==-3){//用户自定义过滤
								filtercustom+=line_record+",";
								int filter=importmap.get("filtercustomnum")+1;
								importmap.put("filtercustomnum",filter);//用户自定义过滤量
							}else if(parseresult==-4){//数据库重复
								scaddr+=line_record+",";
								int scnum=importmap.get("scnum")+1;
								importmap.put("scnum",scnum);//成功量
							}else if(parseresult==-5){//系统过滤
								filtersys+=line_record+",";
								int sysscnum=importmap.get("filtersysnum")+1;
								importmap.put("filtersysnum",sysscnum);//成功量
							}
						}else{
							noaddr+=line_record+",";
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
							continue;
						}
					}else{
						noaddr+=line_record+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
					}
				}
				bufread1.close();
				in1.close();
			}else if("xls".equals(filetype)){
				InputStream in=new FileInputStream(new File(addressFilePath));
				HSSFWorkbook wb = new HSSFWorkbook(in);
				HSSFSheet sheet = wb.getSheetAt(0);//读取第一个工作表
				for(int j = 1; j < sheet.getLastRowNum() + 1; j++){
					HSSFRow row = sheet.getRow(j);
					String Mail_Addr_Name_Var="";
					if(row!=null){
						for(int k = 0; k < row.getLastCellNum(); k++){
							HSSFCell cell = row.getCell((short) k);
							if(cell!=null){
								if (cell.getCellType() == HSSFCell.CELL_TYPE_BOOLEAN){
									// 返回布尔类型的值
									Mail_Addr_Name_Var += String.valueOf(cell.getBooleanCellValue()+",");			           
								}else if (cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC){
									// 返回数值类型的值
									Mail_Addr_Name_Var +=""+",";
								}else{
									// 返回字符串类型的值
									Mail_Addr_Name_Var += String.valueOf(cell.getStringCellValue()+",");
								}
							}
						}
						//处理数据
						String email="";
						String name="";
						String company="";
						String selfbl="";
						String[] emailarry=Mail_Addr_Name_Var.split(",");
						if(emailarry==null||emailarry.length<=0){
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
							continue;
						}
						
						//去掉空格
						email=emailarry[0].trim();
						email = email.replace("<", "&lt;");
						if(emailarry.length>=2){
							name=emailarry[1];
						}
						if(emailarry.length>=3){
							company=emailarry[2];
						}
						if(emailarry.length>=4){
							selfbl=emailarry[3];
						}
						//该行做判断(地址@后面只能有两个点且只能是数字字母)
						String yz1[]=email.split("@");
						//字符长度不能大于60
						if(email.length()>60){
							noaddr+=email+",";
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
							continue;
						}else if(yz1.length!=2){//最多两个.
							noaddr+=email+",";
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
							continue;
						}
						//以字母结尾
						byte b=yz1[1].getBytes()[yz1[1].length()-1];
						if((b>=97&&b<=122)||(b>=65&&b<=90)){
							//System.out.println(yz1[1]);
						}else{
							noaddr+=email+",";
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
							continue;
						}
						Pattern yz = Pattern.compile(emailreg);
						Matcher m = yz.matcher(email);
						email=email.replaceAll(" ", "");
						if(m.matches()){//是正确的
							//易外销用户才验证crm库
							if(user.getUser_type() == 0){
								//判断是不是在crm库中
								int exits=yxyaddressmanageservice.findcrmisexits(user.getCompany_id(),email);
								if(exits==2){
									crmaddr+=email+",";
									int crmnum=importmap.get("crmnum")+1;
									importmap.put("crmnum",crmnum);//crm库重复
									continue;
								}
							}
							int parseresult=parseRecord(email,alllist,unalllist,shielddoamin,noshieldemail,fileEmail,filterstr);
							fileEmail.add(email);
							if(parseresult==0){//可发
								int success=importmap.get("success")+1;
								importmap.put("success",success);//成功量
								//加入对象
								YxyUserAddress addr = new YxyUserAddress(); 
								addr.setUser_addr_type_id(typeid);//所属类别ID
								addr.setUser_addr_name(name);//姓名
								addr.setUser_addr_add_date(nowdate);//建立时间
								addr.setUser_loginid(loginid);//用户账号
								addr.setUser_domain(domain);//用户所属域名
								addr.setUser_addr_sex("男");//性别
								addr.setUser_addr_email(email);//email
								addr.setCompanyname(company);
								addr.setUser_addr_variable(selfbl);
								sendAddrList.add(addr);
							}else if(parseresult>0){//本地库重复
								selfaddr+=email+",";
								int selfnum=importmap.get("selfnum")+1;
								importmap.put("selfnum",selfnum);//本地库重复
							}else if(parseresult==-1){//文件重复
								fcaddr+=email+",";
								int fcnum=importmap.get("fcnum")+1;
								importmap.put("fcnum",fcnum);//文件重复
							}else if(parseresult==-2){//退订
								unaddr+=email+",";
								int unnum=importmap.get("unnum")+1;
								importmap.put("unnum",unnum);//退订
							}else if(parseresult==-3){//用户自定义过滤
								filtercustom+=email+",";
								int filter=importmap.get("filtercustomnum")+1;
								importmap.put("filtercustomnum",filter);//用户自定义过滤量
							}else if(parseresult==-4){//数据库重复
								scaddr+=email+",";
								int scnum=importmap.get("scnum")+1;
								importmap.put("scnum",scnum);//成功量
							}else if(parseresult==-5){//系统过滤
								filtersys+=email+",";
								int sysscnum=importmap.get("filtersysnum")+1;
								importmap.put("filtersysnum",sysscnum);//成功量
							}
						}else{
							noaddr+=email+",";
							int nonum=importmap.get("nonum")+1;
							importmap.put("nonum",nonum);//不合法量
						}
					 }else{
						 noaddr+="为空,";
						 int nonum=importmap.get("nonum")+1;
						 importmap.put("nonum",nonum);//不合法量
					 }
				}
			}else if("xlsx".equals(filetype)){
				InputStream in=new FileInputStream(new File(addressFilePath));
				XSSFWorkbook workbook = new XSSFWorkbook(in);
				XSSFSheet sheet = workbook.getSheetAt(0);
				for (int j = 1; j < sheet.getLastRowNum() + 1; j++) {
	    		XSSFRow  row = sheet.getRow(j);
				String MailAddrAndName="";
				if(row!=null){
					for(int k = 0; k < row.getLastCellNum(); k++){
						XSSFCell cell = row.getCell((short) k);
						if(cell!=null){
							if (cell.getCellType() == HSSFCell.CELL_TYPE_BOOLEAN){
					            // 返回布尔类型的值
								MailAddrAndName += String.valueOf(cell.getBooleanCellValue()+",");			           
					        } 
							else if (cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC){
					        	// 返回数值类型的值
					        	MailAddrAndName +=""+",";
					        }else {
					        	// 返回字符串类型的值
					        	MailAddrAndName += String.valueOf(cell.getStringCellValue()+",");
					        }
						}
					}
					//处理数据
					String email="";
					String name="";
					String company="";
					String selfbl="";
					String[] emailarry=MailAddrAndName.split(",");
					if(emailarry==null||emailarry.length<=0){
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					}
					//去掉空格
					email=emailarry[0].trim();
					email = email.replace("<", "&lt;");
					if(emailarry.length>=2){
						name=emailarry[1];
					}
					if(emailarry.length>=3){
						company=emailarry[2];
					}
					if(emailarry.length>=4){
						selfbl=emailarry[3];
					}
					//该行做判断(地址@后面只能有两个点且只能是数字字母)
					String yz1[]=email.split("@");
					//字符长度不能大于60
					if(email.length()>60){
						noaddr+=email+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					}else if(yz1.length!=2){//最多两个.
						noaddr+=email+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					}
					//以字母结尾
					byte b=yz1[1].getBytes()[yz1[1].length()-1];
					if((b>=97&&b<=122)||(b>=65&&b<=90)){
						//System.out.println(yz1[1]);
					}else{
						noaddr+=email+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					}
					Pattern yz = Pattern.compile(emailreg);
					Matcher m = yz.matcher(email);
					email=email.replaceAll(" ", "");
					if(m.matches()){//是正确的
						//易外销用户才验证crm库
						if(user.getUser_type() == 0){
							//判断是不是在crm库中
							int exits=yxyaddressmanageservice.findcrmisexits(user.getCompany_id(),email);
							if(exits==2){
								crmaddr+=email+",";
								int crmnum=importmap.get("crmnum")+1;
								importmap.put("crmnum",crmnum);//crm库重复
								continue;
							}
						}
						int parseresult=parseRecord(email,alllist,unalllist,shielddoamin,noshieldemail,fileEmail,filterstr);
						fileEmail.add(email);
						if(parseresult==0){//可发
							int success=importmap.get("success")+1;
							importmap.put("success",success);//成功量
							//加入对象
							YxyUserAddress addr = new YxyUserAddress(); 
							addr.setUser_addr_type_id(typeid);//所属类别ID
							addr.setUser_addr_name(name);//姓名
							addr.setUser_addr_add_date(nowdate);//建立时间
							addr.setUser_loginid(loginid);//用户账号
							addr.setUser_domain(domain);//用户所属域名
							addr.setUser_addr_sex("男");//性别
							addr.setUser_addr_email(email);//email
							addr.setCompanyname(company);
							addr.setUser_addr_variable(selfbl);
							sendAddrList.add(addr);
						}else if(parseresult>0){//本地库重复
							selfaddr+=email+",";
							int selfnum=importmap.get("selfnum")+1;
							importmap.put("selfnum",selfnum);//本地库重复
						}else if(parseresult==-1){//文件重复
							fcaddr+=email+",";
							int fcnum=importmap.get("fcnum")+1;
							importmap.put("fcnum",fcnum);//文件重复
						}else if(parseresult==-2){//退订
							unaddr+=email+",";
							int unnum=importmap.get("unnum")+1;
							importmap.put("unnum",unnum);//退订
						}else if(parseresult==-3){//用户自定义过滤
							filtercustom+=email+",";
							int filter=importmap.get("filtercustomnum")+1;
							importmap.put("filtercustomnum",filter);//用户自定义过滤量
						}else if(parseresult==-4){//数据库重复
							scaddr+=email+",";
							int scnum=importmap.get("scnum")+1;
							importmap.put("scnum",scnum);//成功量
						}else if(parseresult==-5){//系统过滤
							filtersys+=email+",";
							int sysscnum=importmap.get("filtersysnum")+1;
							importmap.put("filtersysnum",sysscnum);//成功量
						}
					}else{
						noaddr+=email+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
					}
				}else{
					noaddr+="为空,";
					int nonum=importmap.get("nonum")+1;
					importmap.put("nonum",nonum);//不合法量
				}
			}
		}
			
			importaddress.put("unaddr",unaddr);//退订地址
			importaddress.put("fcaddr",fcaddr);//文件重复地址
			importaddress.put("scaddr",scaddr);//系统重复地址
			importaddress.put("noaddr",noaddr);//不合法地址
			importaddress.put("crmaddr",crmaddr);//crm重复
			importaddress.put("selfaddr",selfaddr);//本地库重复
			importaddress.put("filtercustom",filtercustom);//用户自定义过滤地址
			importaddress.put("filtersys",filtersys);//系统屏蔽
			
			importmap.put("result",1);//成功
			//ActionContext actionContext = ActionContext.getContext();
			//Map<String, Object> sion = actionContext.getSession();
			sess.put("sendaddress", sendAddrList);
		}catch (Exception e){
			importmap.put("result",0);//异常
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return "map";
	} 
	
	/**CRM库发信判断量是否超标*/
	public String checkCRMSendLimit(){
		try{
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();	
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid=user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			//单次发送量已大于设置的量
			if(uploademail.split(",").length > ConfigPath.getSendOnceLimit()){
				importmap.put("result", -1);
				importmap.put("limit", ConfigPath.getSendOnceLimit());
			}else{//单次量没超标则检查发送月发送量
				int check = yxysendmailservice.getThisMonthSendLimit(user.getUser_id(),uploademail,send_time);
				if(check == 0){//已超标
					importmap.put("result", -2);
					importmap.put("limit", ConfigPath.getSendMonthLimit());
				}else{//没超标
					importmap.put("result", 1);
				}
			}
		}catch(Exception e){
			importmap.put("result", 0);
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return "map";
	}
	
	/**新客户营销发信判断量是否超标*/
	public String checkNewSendLimit(){
		try{
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();	
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid=user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			int check = yxysendmailservice.getThisMonthSendLimit2(user.getCompany_id(),user.getUser_id(),send_nums,send_time);
			if(check==1){//没超标
				importmap.put("result", 1);
			}else{//已超标
				if(check==-1){//单次量超标
					importmap.put("result", -1);
					importmap.put("limit", ConfigPath.getSendOnceLimitNew());
				}else if(check==-2){//月发量超标
					importmap.put("result", -2);
					importmap.put("limit", ConfigPath.getSendMonthLimitNew());
				}else{
					importmap.put("result", 1);
				}
			}
		}catch(Exception e){
			importmap.put("result", 0);
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return "map";
	}
	
	/**生成待发邮件*/
	public String generationMail(){
		try{
			//返回值
			importmap.put("result", 0);
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();
			//获取session中的yxyuser
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			//用户账号
			loginid=user.getLogin_id();
			//用户所属域名
			domain=user.getDomain();
			//时间定义
			SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String nowdate=df.format(new Date());
			SimpleDateFormat df1=new SimpleDateFormat("yyyyMMddHHmmssSSS");
			String romdate=df1.format(new Date());
			
			//获取项目在服务器端的路径	
			String pathew = this.getClass().getClassLoader().getResource("/").getPath();
			pathew = pathew.substring(1, pathew.length());
			pathew = pathew.replace("/WEB-INF/classes/","");
			
			//发件人
			sender=sender.replace("lt&", "<");
			sender=sender.replace("gt&", ">");
			//发件人姓名
			String sendname=sender.substring(0,sender.indexOf("<"));
			//发件人地址
			String sendaddr=sender.substring(sender.indexOf("<")+1,sender.lastIndexOf(">"));
			//回复人地址
			String replyaddr="";
			replyemail=replyemail.replace("lt&", "<");
			replyemail=replyemail.replace("gt&", ">");
			if(replyemail.indexOf("<")==-1){
				replyaddr=replyemail;
			}else{
				replyaddr=replyemail.substring(replyemail.indexOf("<")+1,replyemail.lastIndexOf(">"));
			}

			//用户提交的地址
			List<YxyUserAddress> sendaddress =new ArrayList<YxyUserAddress>();
			//用户提交的地址信息
			sendaddress =(List<YxyUserAddress>)sess.get("sendaddress");
			
			//用户是否选择了过滤分组功能
			if(filterid>=0){
				//根据过滤类别ID查询地址与域名
				List<Object> filterAddressList=filteraddressservice.findByTypeidAddress(filterid);
				//循环判断待发地址是否在过滤地址中
				if(filterAddressList.size()>0){
					String filterAddress="";
					String addressStr="";
					for(int l=0;l<filterAddressList.size();l++){
						for(int u=0;u<sendaddress.size();u++){//address是用户上传的收件人地址
							filterAddress=filterAddressList.get(l).toString();
							addressStr=sendaddress.get(u).getUser_addr_email();
							//判断用户上传的地址与过滤中地址是否相同
							if(addressStr.equals(filterAddress)||addressStr.indexOf(filterAddress)!=-1){
								//移出该对象
								sendaddress.remove(u);
							}
						}
					}
				}
			}
			
			//用户并没有上传地址或者选择地址
			if(sendaddress==null||sendaddress.size()<=0){
				importmap.put("result", -1);//无地址
				return "map";
			}
			//验证
			if(sendci!=1){
				int yz=sendYZ(sendaddress);
				if(yz!=1){
					importmap.put("result", yz);
					return "map";
				}
			}
			//生成待发邮件与地址
			YxySendMailMaster masterinfo=new YxySendMailMaster();
			masterinfo.setSubject(title);//主题
			masterinfo.setSender(sendname);//发件人姓名
			masterinfo.setSend_email(sendaddr);//发件人地址
			masterinfo.setReply_email(replyaddr);//回复地址
			masterinfo.setBody(context);//内容
			masterinfo.setUser_loginid(loginid);//用户账号
			masterinfo.setUser_domain(domain);//用户域名
			masterinfo.setCreate_time(nowdate);//创建时间
			masterinfo.setFolder_id(0);//所属文件类别ID
			masterinfo.setAuto_change_subject(ismanytitle);//是否使用多主题
			masterinfo.setAttarchment_path(pathew+"##P##"+attrpath);//加入附件路径
			String random=GetRandom.getRandomString(10);//获取随机数据制定邮件唯一码
			String mailUID=loginid+romdate+random;//邮件唯一码由用户域名+时间格式+随机数
			masterinfo.setMail_uid(mailUID);//加入唯一码
			masterinfo.setMainid(mainid);//加入主邮件id
			masterinfo.setSendci(1);
			//masterinfo.setUid(uid);
			//是不是老客户营销
			if(uploadtype==1||uploadtype==2){//新客户营销(导入地址、粘贴地址)
				//本月新客户营销发送量已经超标或单次发送量超标则改为新客户营销但是我们系统得smtp发送
				if(yxysendmailservice.getThisMonthSendLimit2(user.getCompany_id(),user.getUser_id(),sendaddress.size(),send_time)!=1){
					masterinfo.setIsold(6);
				}else{//发送量没超标
					//获取EDM配置-开发客户配置信息
					CentreYxyedmNewcustomer new_set = yxysendmailservice.getNewCusSet(user.getCompany_id());
					if(new_set!=null){//有配置信息
						//是自有域名且状态可以使用
						if(new_set.getType() == 0 && new_set.getStatus() == 1){
							//查询当前帐号是否有smtp信息
							String hql = "from YxySendSmtpInfo where smtp_user_loginid = '"+loginid+"' and smtp_user_domain = '"+domain+"' and smtp_service_type = 5";
							List<YxySendSmtpInfo> smtps = yxysendmailservice.findSmtpByHql(hql);
							if(smtps.size() > 0){//开发客户的自有域名模式有对应的smtp
								masterinfo.setIsold(5);//使用开发客户的自有域名得smtp发送
							}else{
								masterinfo.setIsold(0);//系统的smtp发送
							}
						}else{//非自有域名或者状态不可使用
							masterinfo.setIsold(0);//系统的smtp发送
						}
					}else{//无配置信息
						masterinfo.setIsold(0);//系统的smtp发送
					}
				}
			}else if(uploadtype==4||uploadtype==7){//客户管理
				//本月CRM库发送量已经超标或单次发量超标则改为CRM库营销但是老客户营销发送
				if(yxysendmailservice.getThisMonthSendLimit(user.getUser_id(),uploademail,send_time) == 0 ||
						uploademail.split(",").length > ConfigPath.getSendOnceLimit()){
					masterinfo.setIsold(4);
				}else{//发送量没超标
					//获取EDM配置-盘活客户配置信息
					CentreYxyedmOldcustomer old_set = yxysendmailservice.getOldCusSet(user.getCompany_id());
					if(old_set!=null){//有配置信息
						if(old_set.getStatus()==1){//状态可以用
							if(old_set.getType()==0){//自有域名
								//查询当前帐号是否有smtp信息
								String hql = "from YxySendSmtpInfo where smtp_user_loginid = '"+loginid+"' and smtp_user_domain = '"+domain+"' and smtp_service_type = 3";
								List<YxySendSmtpInfo> smtps = yxysendmailservice.findSmtpByHql(hql);
								if(smtps.size() > 0){//有smtp信息
									masterinfo.setIsold(3);//用自己的域名帐号发信
								}else{//无smtp信息则改为CRM库营销但是老客户营销发送
									masterinfo.setIsold(4);
								}
							}else{//代发模式
								//查询当前帐号是否有smtp信息
								String hql = "from YxySendSmtpInfo where smtp_user_domain = '"+domain+"' and smtp_service_type = 2";
								List<YxySendSmtpInfo> smtps = yxysendmailservice.findSmtpByHql(hql);
								if(smtps.size() > 0){//有smtp信息
									masterinfo.setIsold(2);//该企业下的用户都用同一个指定的帐号发信
								}else{//无smtp信息则改为CRM库营销但是老客户营销发送
									masterinfo.setIsold(4);
								}
							}
						}else{//状态不可以用则改为CRM库营销但是老客户营销发送
							masterinfo.setIsold(4);
						}
					}else{//没配置信息则改为CRM库营销但是老客户营销发送
						masterinfo.setIsold(4);
					}
				}
			}else{
				masterinfo.setIsold(1);//老客户跟进
			}
			//是不是在发一次
			if(mailid>0){
				masterinfo.setMainid(mailid);
			}
			//是否加入退订
			masterinfo.setIs_unsubscribe(1);
			//选择的退订语言
			masterinfo.setUnsubscribe_language(unlanguage);
			masterinfo.setUnstr(unselfstr);
			//用户eml保存路径
			String usersetpath=yxysysparamaterservice.findUserParamValue(loginid, domain, "yxy_user_data_save_path", "yxy_domain_save_path");
			String sendStatus="send";
			  
			//判断是不是定时邮件
			if(!timestr.equals("no")){
				masterinfo.setStatus(2);//状态为定时邮件
				masterinfo.setPlans_send(1);
				masterinfo.setPlans_send_time(timestr);
				sendStatus="time";
			}
			String saveemlpath=usersetpath+"\\"+domain+"\\"+loginid+"\\"+"\\"+sendStatus;
			//调用业务层
			yxysendmailservice.addMasterDetail(user.getUser_type(),user.getCompany_id(),user.getUser_id(),masterinfo,sendaddress,attrpath,saveemlpath,usersetpath,mailid,sendci,uploadtype,customerid,jinchengid);
			
			//添加此次发送的邮件内容大小提供内容过滤使用
//			YxySendContextSet yxysendcontextset = new YxySendContextSet();
//			yxysendcontextset.setLogin_id(loginid);//登录帐号
//			yxysendcontextset.setLogin_domain(domain);//登录域名
//			yxysendcontextset.setEmail_subject(title);//邮件主题
//			yxysendcontextset.setEmail_context_size(context.getBytes().length+"");//邮件大小(字节数)
//			yxysendcontextset.setEmail_send_time(nowdate.split(" ")[0]);//邮件发送时间，格式为yyyy-mm-dd
//			yxycontextsetservice.addContexsetInfo(yxysendcontextset);//添加邮件信息内容
			
			//importmap.put("result", 1);
			//地址量
			importmap.put("result", sendaddress.size());
			
			//清除地址session
			sess.remove("importaddress");
		}catch (Exception e){
			importmap.put("result", 0);
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return "map";
	}

	/**验证地址(粘贴地址,crm库选择,本地库选择,再发送一次)*/
	public String validateAddress(){
		try{
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();	
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid=user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			
			//当前时间
			SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String nowdate=df.format(new Date());
			
			//返回参数定义
			importmap.put("result",0);//结果
			importmap.put("success",0);//成功量
			importmap.put("tolnum",0);//地址总量
			importmap.put("unnum",0);//退订量
			importmap.put("fcnum",0);//文件重复
			importmap.put("scnum",0);//系统重复
			importmap.put("crmnum",0);//CRM重复
			importmap.put("nonum",0);//不合法量
			importmap.put("filtercustomnum",0);//用户自定义过滤地址
			importmap.put("filtersysnum",0);//系统屏蔽
			
			importaddress.put("unaddr","");//退订地址
			importaddress.put("fcaddr","");//文件重复地址
			importaddress.put("scaddr","");//系统重复地址
			importaddress.put("crmaddr","");//CRM重复
			importaddress.put("noaddr","");//不合法地址
			importaddress.put("filtercustom","");//用户自定义过滤地址
			importaddress.put("filtersys","");//系统屏蔽
			
			String unaddr="";//退订地址
			String fcaddr="";//文件重复地址
			String scaddr="";//系统重复地址
			String crmaddr="";//系统重复地址
			String noaddr="";//不合法地址
			String filtercustom="";//用户自定义过滤地址
			String filtersys="";//系统屏蔽地址
			String filterstr="";//用户自定义过滤字符
			//查询用户个人设置多少天不可以发送相同邮件地址 
			List<YxyUserSet> yxyuserset=yxysendmailservice.findUserSet(loginid,domain);
			if(yxyuserset.size()>0){
				//用户自定义过滤字符
				filterstr=yxyuserset.get(0).getUser_set_fiterStr();
			}		
//			//地址集合
//			List<Object> alllist = new ArrayList<Object>();
//			if(uploadtype==7){//客户管理转过来的
//				//查询crm库(新营销去掉整个企业的CRM库地址)
//				alllist=customerservice.findCusEmailList(user.getCompany_id());
//			}else{
//				//查询本地用户地址库
//				alllist=yxyaddressmanageservice.findUserAllAddress(loginid,domain);
//			}
			//查询用户退订地址
			List<Object> unalllist=yxyunsubscribeinfoservice.findAllUnEmali(loginid,domain);
			//可发地址对象
			List<YxyUserAddress> sendAddrList = new ArrayList<YxyUserAddress>();
			//查询屏蔽的域名
			List<YxyShieldDomain> shielddoamin=shielddomainservice.findAllList();
			//查询不屏蔽的邮件地址
			List<YxyNoshieldEmail> noshieldemail=noshieldemailservice.findAllList();
			//存放判断之后的地址
			List<String> fileEmail=new ArrayList<String>();
			//需要判断的地址集合
			List<Object> yzaddresslist=new ArrayList<Object>();
			List<YxyCustomerEmail> crmaddresslist=new ArrayList<YxyCustomerEmail>();
			//判断提交方式
			if(uploadtype==2){//粘贴的去掉本地地址库里的，与crm库里面的
				uploademail=uploademail.replaceAll(";", ",");
				uploademail=uploademail.replaceAll(" ", "");
				String[] arrayemail=uploademail.split(",");
				if(uploadtype==2&&arrayemail.length>20){
					importmap.put("result",-1);//结果
					return "map";
				}
				//处理空字符
				for(int i=0;i<arrayemail.length;i++){
					if(arrayemail[i]!=null&&!"".equals(arrayemail[i])){
						String [] addrArry={arrayemail[i],""};
						yzaddresslist.add(addrArry);
					}
				}
			}else if(uploadtype==6){//本地库地址选择
				uploademail=uploademail.replaceAll(";", ",");
				uploademail=uploademail.replaceAll(" ", "");
				String[] arrayemail=uploademail.split(",");
				//处理空字符
				for(int i=0;i<arrayemail.length;i++){
					if(arrayemail[i]!=null&&!"".equals(arrayemail[i])){
						String [] addrArry={arrayemail[i],""};
						yzaddresslist.add(addrArry);
					}
				}
			}else if(uploadtype==3){//本地库类别选择
				//查询本地库地址(根据类别)
				yzaddresslist=yxyaddressmanageservice.findAddressTypeid(loginid,domain,typeid);
				if(yzaddresslist.size()<=0){
					importmap.put("result",1);//结果
					return "map";
				}
			}else if(uploadtype==4){//crm分类
				crmaddresslist=customerservice.findEmailByCusid(uploademail);
				if(crmaddresslist==null||crmaddresslist.size()<=0){
					importmap.put("result",1);//结果
					return "map";
				}else{
					for(int i=0;i<crmaddresslist.size();i++){
						String fullname=crmaddresslist.get(i).getFull_name();
						String cusname=crmaddresslist.get(i).getCustomer_name();
						String email=crmaddresslist.get(i).getEmail();
						int customer_id=crmaddresslist.get(i).getCustomer_id();
						Object[] obj={email,customer_id,fullname,cusname};
						yzaddresslist.add(obj);
					}
				}
			}else if(uploadtype==5){//再发一次
				//判断邮件间隔时间大于90天的不能再发一次
				String timejian=DateFormat.nDaysAfterOneDateString(nowdate,-90);
				//往前推时时间修改为00:00:00而不是08:00:00
				timejian = timejian.split(" ")[0] + " 00:00:00";
				//判断最后一封邮件的时间
				String lasttime=yxysendmailservice.findLastMail(mailid);
				if(lasttime.compareTo(timejian)<0){
					importmap.put("result",-3);//结果
					return "map";
				}
				//项目路进	
				String pathew = this.getClass().getClassLoader().getResource("/").getPath();
				pathew = pathew.substring(1, pathew.length());
				pathew = pathew.replace("/WEB-INF/classes/","");
				//获取txt名称
				String txtname=yxysendmailservice.findMailTxtPath(mailid);
				if("".equals(txtname)){
					importmap.put("result",-2);//结果
					return "map";
				}
				//组装路径
				String txtfilepath="userSaveFile/"+domain+"/"+loginid+"/"+txtname;
				//判断文件是否存在
				File f=new File(pathew+"/"+txtfilepath);
				if(f.exists()){
					//判断txt还是excel
					String[] typeArry=txtname.split("\\.");
					String typename=typeArry[typeArry.length-1];
					if("txt".equals(typename)){
						//获取文件内容
						InputStreamReader in = new InputStreamReader(new FileInputStream(f), "UTF-8");
						BufferedReader bufread = new BufferedReader(in);
						String line_record ="";
						int line=0;
						while((line_record = bufread.readLine())!=null){
							line++;
							if(line==1){
								continue;
							}
							String [] sendarry={line_record,"","","",""};
							yzaddresslist.add(sendarry);
						}
					}else if("xls".equals(typename)){
						//获取文件内容excel
						InputStream in=new FileInputStream(f);
						HSSFWorkbook wb = new HSSFWorkbook(in);
						HSSFSheet getsheet = wb.getSheetAt(0);//读取第一个工作表
						for(int j = 1; j < getsheet.getLastRowNum() + 1; j++){
							HSSFRow getrow = getsheet.getRow(j);
							String readinfo="";
							if(getrow!=null){
								for(int k = 0; k < getrow.getLastCellNum(); k++){
									HSSFCell getcell = getrow.getCell((short) k);
									if(getcell!=null){
										if (getcell.getCellType() == HSSFCell.CELL_TYPE_BOOLEAN){
											// 返回布尔类型的值
											readinfo += String.valueOf(getcell.getBooleanCellValue()+",");			           
										}else if (getcell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC){
											// 返回数值类型的值
											readinfo +=Integer.valueOf(getcell.getStringCellValue())+",";
										}else{
											// 返回字符串类型的值
											readinfo += String.valueOf(getcell.getStringCellValue()+",");
										}
									}
								}
								//处理数据
								String email="";
								String name="";
								String company="";
								String selfbl="";
								String[] emailarry=readinfo.split(",");
								if(emailarry==null||emailarry.length<=0){
									continue;
								}
								//去掉空格
								email=emailarry[0].trim();
								if(emailarry.length>=2){
									name=emailarry[1];
								}
								if(emailarry.length>=3){
									company=emailarry[2];
								}
								if(emailarry.length>=4){
									selfbl=emailarry[3];
								}
								String [] sendarry={email,name,company,selfbl};
								yzaddresslist.add(sendarry);
							}
						}	
					}
				}else{
					importmap.put("result",-2);//结果
					return "map";
				}
			}else if(uploadtype==7){//客户管理转过来的
				crmaddresslist=customerservice.findEmailByCusid(uploademail);
				if(crmaddresslist==null||crmaddresslist.size()<=0){
					importmap.put("result",1);//结果
					return "map";
				}else{
					for(int i=0;i<crmaddresslist.size();i++){
						String fullname=crmaddresslist.get(i).getFull_name();
						String cusname=crmaddresslist.get(i).getCustomer_name();
						String email=crmaddresslist.get(i).getEmail();
						int customer_id=crmaddresslist.get(i).getCustomer_id();
						Object[] obj={email,customer_id,fullname,cusname};
						yzaddresslist.add(obj);
					}
				}
//				uploademail=uploademail.replaceAll(";", ",");
//				uploademail=uploademail.replaceAll(" ", "");
//				String[] arrayemail=uploademail.split(",");
//				//循环处理数据
//				for(int i=0;i<arrayemail.length;i++){
//					if(arrayemail[i]!=null&&!"".equals(arrayemail[i])){
//						String [] addrArry={arrayemail[i],""};
//						yzaddresslist.add(addrArry);
//					}
//				}
			}
			
			List<Object> readlist=null;
			if(uploadtype==5){//在发一次去掉点读的(当前邮件的)
				readlist=yxyreadinginfoservice.findMailReadAddress(loginid,domain,mailid);
			}
			
			//地址集合
			List<Object> alllist = new ArrayList<Object>();
			if(uploadtype == 1 || uploadtype == 2 || uploadtype==3 || uploadtype==6){//发送地址的方式1:上传,2:粘贴,3:本地库类别选择,6:本地库地址选择
				if(user.getUser_type() == 0){//易外销用户
					alllist=customerservice.findCusEmailList(user.getCompany_id());
				}else{//营销邮用户
					alllist=yxyaddressmanageservice.findUserAllAddress(loginid,domain);
				}
			}
			
			//循环判断地址
			our:for(int s=0;s<yzaddresslist.size();s++){
				//发送地址的方式1:上传2:粘贴3:本地库类别选择4:crm分类5:在发一次6:本地库多地址选择7:客户管理传来的8:通讯录
				Object[] obj=(Object[]) yzaddresslist.get(s);
				String email=obj[0].toString();
				if(uploadtype==1||uploadtype==2){//邮件地址格式判断只针对于上传和粘贴
					if(obj[0]==null){
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					}
					//字符长度不能大于60
					if(email.length()==0||email.length()>60){
						noaddr+=email+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					}
					//该行做判断(地址@后面只能有两个点且只能是数字字母)
					String yz1[]=email.split("@");
					if(yz1.length!=2){//最多两个.
						noaddr+=email+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					}
					//以字母结尾
					byte b=yz1[1].getBytes()[yz1[1].length()-1];
					if(!(b>=97&&b<=122)&&!(b>=65&&b<=90)){
						noaddr+=email+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					} 
					//去掉空格
					email=email.trim();
					Pattern yz = Pattern.compile(emailreg);
					Matcher m = yz.matcher(email);
					email=email.replaceAll(" ", "");
					if(!m.matches()){
						noaddr+=email+",";
						int nonum=importmap.get("nonum")+1;
						importmap.put("nonum",nonum);//不合法量
						continue;
					}
				}
				//是正确的
				if(uploadtype==5){//在发一次去掉点读的(当前邮件的)
					//是否有点读(去掉点读的)
					if(readlist!=null){
						for(int r=0;r<readlist.size();r++){
							String reademail=readlist.get(r).toString();
							if(email.equals(reademail)){
								continue our;
							}
						}
					}
				}

				//验证合法性
				int parseresult=parseRecord(email,alllist,unalllist,shielddoamin,noshieldemail,fileEmail,filterstr);
				fileEmail.add(email);
				//粘贴去掉本地地址库
				if(uploadtype==2){
					if(parseresult>0){
						parseresult=-4;
					}else{
						//查询crm库(新营销去掉整个企业的CRM库地址)
						int exits=yxyaddressmanageservice.findcrmisexits(user.getCompany_id(),email);
						if(exits==2){
							parseresult=-6;
							break;
						}
					}
				}
				//判断结果
				if(parseresult>=0){//存在的地址
					//加入对象
					YxyUserAddress addr = new YxyUserAddress();  
					//是否历史存在
					if(parseresult>0){//大于0说明是匹配到了本地库的信息即uploadtype=1或uploadtype=2
						addr=yxyaddressmanageservice.findaddressinfo(parseresult);
					}else{//说明parseresult=0
						addr.setUser_addr_id(0);//地址id
						addr.setUser_addr_email(email);//地址
						addr.setUser_addr_type_id(typeid);//所属类别ID
						addr.setUser_addr_name("");//姓名
						addr.setUser_addr_add_date(nowdate);//建立时间
						addr.setUser_loginid(loginid);//用户账号
						addr.setUser_domain(domain);//用户所属域名
						addr.setUser_addr_sex("男");//性别
						if(uploadtype==5){//再发一次
							addr.setUser_addr_name(obj[1].toString());//姓名
							addr.setCompanyname(obj[2].toString());
							addr.setUser_addr_variable(obj[3].toString());
						}
						else if(uploadtype==4 || uploadtype==7){//从CRM库选择
							addr.setCustomerid(Integer.parseInt(obj[1].toString()));//客户id
							addr.setUser_addr_name(obj[2].toString());//姓名
							addr.setCompanyname(obj[3].toString());//客户名称
						}
					} 
					sendAddrList.add(addr);
				}else if(parseresult==-1){//文件重复
					fcaddr+=email+",";
					int fcnum=importmap.get("fcnum")+1;
					importmap.put("fcnum",fcnum);//文件重复
				}else if(parseresult==-2){//退订
					unaddr+=email+",";
					int unnum=importmap.get("unnum")+1;
					importmap.put("unnum",unnum);//退订
				}else if(parseresult==-3){//用户自定义过滤
					filtercustom+=email+",";
					int filter=importmap.get("filtercustomnum")+1;
					importmap.put("filtercustom",filter);//过滤量
				}else if(parseresult==-4){//数据库重复
					scaddr+=email+",";
					int scnum=importmap.get("scnum")+1;
					importmap.put("scnum",scnum);//过滤量
				}else if(parseresult==-5){//系统屏蔽
					filtersys+=email+",";
					int scnum=importmap.get("filtersysnum")+1;
					importmap.put("filtersysnum",scnum);//系统屏蔽量
				}else if(parseresult==-6){//CRM重复
					crmaddr+=email+",";
					int crmnum=importmap.get("crmnum")+1;
					importmap.put("crmnum",crmnum);//CRM重复量
				}
			}
			
			//保存值
			ActionContext actionContext = ActionContext.getContext();
			Map<String, Object> sion = actionContext.getSession();
			sion.put("sendaddress", sendAddrList);
			//返回结果
			importmap.put("success",sendAddrList.size());//结果
			importaddress.put("unaddr",unaddr);//退订地址
			importaddress.put("fcaddr",fcaddr);//文件重复地址
			importaddress.put("scaddr",scaddr);//系统重复地址
			importaddress.put("noaddr",noaddr);//不合法地址
			importaddress.put("filtercustom",filtercustom);//用户自定义过滤地址
			importaddress.put("filtersys",filtersys);//系统屏蔽
			importmap.put("result",1);//结果
		}catch(Exception e){
			importmap.put("result",0);//结果
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return "map";
	}
	
	/**解析记录验证正确性*/
	public int parseRecord(String line_record,List<Object> existAddress,
			List<Object> unAddress,List<YxyShieldDomain> shielddoamin,
			List<YxyNoshieldEmail> noshieldemail,List<String> fileEmail,String filter){//,int isrepeatday
		//发送地址的方式1:上传2:粘贴
		if(uploadtype==1||uploadtype==2){
			//判断此地址在之前是否导入过
			for(int v=0;v<fileEmail.size();v++){
				if(line_record.equals(fileEmail.get(v))){
					return -1;
				}
			}
		}
		//地址是否是退订地址
		for(int u=0;u<unAddress.size();u++){
			 //判断是否与退订地址一样
			if(unAddress.get(u).equals(line_record)){
				return -2;
			}
		}
		//自定义过滤
		if(filter!=null&&!filter.equals("")){
			 //判断此地址是否过滤
			 String []fiterArry=filter.split(";");
			 for(int f=0;f<fiterArry.length;f++){
				 if(line_record.split("@")[0].equals(fiterArry[f])){
					 return -3;
				 }
			 }
		}
		boolean isshield=true;
		//不屏蔽相关后缀的邮箱
		for(int n=0;n<noshieldemail.size();n++){
			if(line_record.equals(noshieldemail.get(n).getEmail())){
				isshield=false;
				break;
			}
		}
		//屏蔽相关后缀的邮箱
		if(isshield){
			for(int s=0;s<shielddoamin.size();s++){
				if(line_record.contains(shielddoamin.get(s).getShielddomain())){
					return -5;
				}
			}
		}
		//发送地址的方式1:上传,2:粘贴,3:本地库类别选择,6:本地库地址选择
		if(uploadtype==1||uploadtype==2||uploadtype==3||uploadtype==6){
			//地址是否重复
			Object[] emailarry=null;
			for(int i=0;i<existAddress.size();i++){
				emailarry=(Object[]) existAddress.get(i);
				int addressid=Integer.parseInt(emailarry[0].toString());//地址ID
				String email=emailarry[1].toString();//地址
				if(line_record.equals(email)){//已存在
					return addressid;
				 }
			 }
		}
		return 0;
	}

	/**发送邮件的各种判断*/
	public int sendYZ(List<YxyUserAddress> sendaddress){
		try {
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();			
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid=user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			//当前时间
			SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String nowdate=df.format(new Date());
			String nowDay=nowdate.split(" ")[0];
			
			
			if(sendaddress.size()<=0){
				return -6;//过滤后无可发地址
			}
			//待发送地址量
			int sendaddressnum=sendaddress.size();
			
			//量控制
			Map<String,String> usergraph=yxysysparamaterservice.findParamaterByLevel(4, loginid,domain);//查询控制参数(用户级)
			//Map<String,String> domaingraph=yxysysparamaterservice.findParamaterByLevel(1, loginid,domain);//查询控制参数(企业级)
			
			//判断是不是定时邮件
			if(!timestr.equals("no")){//定时邮件
				//相差的天数
				int nday = DateFormat.nDaysBetweenTwoDate(nowDay,timestr);
				//判断定时的时间是否当天，若是则要判断用户的发信量
				if(nday == 0){//说明定时邮件是当天，则要判断用户的发信量
					//判断用户发信量限制
					int sendresult=yxysendmailservice.findSendNum(loginid,domain,sendaddressnum,usergraph);
					if(sendresult!=1){//-2日超,-3月超,-4总超,-5单次超
						return sendresult;
					}
				}else{//定时邮件不是当天的，则要判断定时邮件的时间的用户发信量是否超标
					int sendresult=yxysendmailservice.findSendNumTime(loginid,domain,sendaddressnum,usergraph,timestr);
					if(sendresult!=1){//-2日超,-3月超,-4总超,-5单次超
						return sendresult;
					}
				}
			}else{//不是定时邮件
				//判断用户发信量限制
				int sendresult=yxysendmailservice.findSendNum(loginid,domain,sendaddressnum,usergraph);
				if(sendresult!=1){//-2日超,-3月超,-4总超,-5单次超
					return sendresult;
				}
			}
			
			//相同邮件内容的发送判断(通过内容的大小的字节数与主题去判断)
//			List<YxyUserSet> userset = yxysendmailservice.findUserSet(loginid,domain);//查询用户个人设置多少天不可以发送相同邮件地址 
//			if(userset.size() > 0){
//				//获取天数据
//				int notsendday=userset.get(0).getUser_not_send_repeat_context_num();
//				//获取日期
//				String ntimer=DateFormat.nDaysAfterOneDateString(nowdate,notsendday);
//				String bodylength=context.getBytes().length+"";
//				List<YxySendContextSet> contextset=yxycontextsetservice.findByTime(nowDay,nowDay,bodylength,ntimer,title);
//				if(contextset.size()>0){//有相同的
//					return -8;
//				}
//			}
			
		} catch (Exception e) {
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
			return 0;
		}
		return 1;
	}
		
	/**判断定时邮件定时时间是否在当前时间后6小时*/
	public String sendTimeBegin(){
		try {
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();			
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid=user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			String nowdate=DateFormat.getNowDate();
			long begintime=DateFormat.minutes(nowdate,timestr);
			if(begintime>360){
				result=1;
			}else{
				result=-1;
			}
		} catch (Exception e) {
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return SUCCESS;
	}
	
	/**判断当前用户是否有新客户营销权限:0没有,1有*/
	public String getNewCusPower(){
		try {
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();			
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid = user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			result = yxysendmailservice.getNewCusPower(domain,user.getCompany_id(),user.getUser_id());
		} catch (Exception e) {
			result = 0;
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return SUCCESS;
	}
	
	/**若发送的是客户则处理发送发送后的业务*/
	public String updateCustomerService(){
		try {
			//获取用户session
			ActionContext ac = ActionContext.getContext();
			Map<String,Object> sess = ac.getSession();			
			YxyUserInfo user=(YxyUserInfo) sess.get("yxyuser");
			loginid = user.getLogin_id();//用户账号
			domain=user.getDomain();//用户所属域名
			yxysendmailservice.updateCustomerService(user.getDomain(),user.getLogin_id(),user.getCompany_id(),user.getUser_id(),timestr,uploadtype,customerid,jinchengid,title);
			result = 1;
		} catch (Exception e) {
			result = 0;
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw, true));
	        String str = sw.toString();
	        LogClass.errolog(str,loginid+"@"+domain);
		}
		return SUCCESS;
	}
	
	private int filterid;//过滤类别ID
	private int ismanytitle;//是否使用多主题
	private int unlanguage;//退订语言(1:中文2:英文3:自定义)
	private int mailid;//邮件id
	private int sendci;//发送次数
	private int uploadtype;//发送地址的方式1:上传2:粘贴3:本地库类别选择4:crm分类5:在发一次6:本地库多地址选择7:客户管理传来的8:通讯录
	private int result;//返回结果
	private int typeid;//地址所属类别ID
	private int mainid;//在发一次的主邮件id
	private int jinchengid;//进程id(客户管理)
	private String unselfstr;//自定义退订字符
	private String loginid="erro";//用户账号
	private String domain="erro";//用户域名
	private String sender;//发件人
	private String replyemail;//回复地址
	private String context;//内容
	private String timestr;//是否是定时邮件(不是则为no,是则为定时时间)
	private String title;//主题
	private String uploademail;//提交的地址
	private String linkadderss;//链接地址
	private String attrpath;//附件
	private String txtfilename;//邮件txt文件名
	private String addrfilename;//上传文件名
	private String customerid;//客户id(多个)
	private Map<String,Integer> importmap=new HashMap<String, Integer>();
	private Map<String,String> importaddress=new HashMap<String, String>();
	private Map<String,List<String>> erromap=new HashMap<String, List<String>>();
	private File yxyaddr;//导入的文件路径
	private YxySendMailService yxysendmailservice;//营销service
	private YxyAddressManageService yxyaddressmanageservice;//地址库service
	private YxyUnsubscribeInfoService yxyunsubscribeinfoservice;//退订地址service
	private YxyContextSetService yxycontextsetservice;//内容重复判断service
	private YxySysParamaterService yxysysparamaterservice;//控制参数serviec
	private YxySendFilterAddressService filteraddressservice;//过滤分组地址service
	private YxySendSysFilterService yxysendsysfilterservice;//过滤字符service
	private YxyUserInfoService yxyuserinfoservice;//用户service
	private YxyNoshieldEmailService noshieldemailservice;//不屏蔽的邮件地址service
	private YxyShieldDomainService shielddomainservice;//屏蔽的域名service
	private YxyCustomerService customerservice;//客户service
	private YxyReadingInfoService yxyreadinginfoservice;//点击service
	private String salesResult;//返回crm销售进程结果
	private List<String> listResult=new ArrayList<String>();//发送邮件返回不健康的邮件主题
	private String send_time;//定时邮件的时间
	private int send_nums;//新客户营销发送的邮件地址数
	public int getSend_nums() {
		return send_nums;
	}
	public void setSend_nums(int send_nums) {
		this.send_nums = send_nums;
	}
	public String getSend_time() {
		return send_time;
	}
	public void setSend_time(String send_time) {
		this.send_time = send_time;
	}
	public String getSalesResult() {
		return salesResult;
	}
	public void setSalesResult(String salesResult) {
		this.salesResult = salesResult;
	}
	public List<String> getListResult() {
		return listResult;
	}
	public void setListResult(List<String> listResult) {
		this.listResult = listResult;
	}
	public YxySendMailService getYxysendmailservice() {
		return yxysendmailservice;
	}
	public void setYxysendmailservice(YxySendMailService yxysendmailservice) {
		this.yxysendmailservice = yxysendmailservice;
	}
	public YxyAddressManageService getYxyaddressmanageservice() {
		return yxyaddressmanageservice;
	}
	public void setYxyaddressmanageservice(
			YxyAddressManageService yxyaddressmanageservice) {
		this.yxyaddressmanageservice = yxyaddressmanageservice;
	}
	public YxyUnsubscribeInfoService getYxyunsubscribeinfoservice() {
		return yxyunsubscribeinfoservice;
	}
	public void setYxyunsubscribeinfoservice(
			YxyUnsubscribeInfoService yxyunsubscribeinfoservice) {
		this.yxyunsubscribeinfoservice = yxyunsubscribeinfoservice;
	}
	public YxyContextSetService getYxycontextsetservice() {
		return yxycontextsetservice;
	}
	public void setYxycontextsetservice(YxyContextSetService yxycontextsetservice) {
		this.yxycontextsetservice = yxycontextsetservice;
	}
	public YxySysParamaterService getYxysysparamaterservice() {
		return yxysysparamaterservice;
	}
	public void setYxysysparamaterservice(
			YxySysParamaterService yxysysparamaterservice) {
		this.yxysysparamaterservice = yxysysparamaterservice;
	}
	public YxySendFilterAddressService getFilteraddressservice() {
		return filteraddressservice;
	}
	public void setFilteraddressservice(
			YxySendFilterAddressService filteraddressservice) {
		this.filteraddressservice = filteraddressservice;
	}
	public YxySendSysFilterService getYxysendsysfilterservice() {
		return yxysendsysfilterservice;
	}
	public void setYxysendsysfilterservice(
			YxySendSysFilterService yxysendsysfilterservice) {
		this.yxysendsysfilterservice = yxysendsysfilterservice;
	}
	public YxyUserInfoService getYxyuserinfoservice() {
		return yxyuserinfoservice;
	}
	public void setYxyuserinfoservice(YxyUserInfoService yxyuserinfoservice) {
		this.yxyuserinfoservice = yxyuserinfoservice;
	}
	public YxyNoshieldEmailService getNoshieldemailservice() {
		return noshieldemailservice;
	}
	public void setNoshieldemailservice(YxyNoshieldEmailService noshieldemailservice) {
		this.noshieldemailservice = noshieldemailservice;
	}
	public YxyShieldDomainService getShielddomainservice() {
		return shielddomainservice;
	}
	public void setShielddomainservice(YxyShieldDomainService shielddomainservice) {
		this.shielddomainservice = shielddomainservice;
	}
	public String getLoginid() {
		return loginid;
	}
	public void setLoginid(String loginid) {
		this.loginid = loginid;
	}
	public String getDomain() {
		return domain;
	}
	public void setDomain(String domain) {
		this.domain = domain;
	}
	public Map<String, Integer> getImportmap() {
		return importmap;
	}
	public void setImportmap(Map<String, Integer> importmap) {
		this.importmap = importmap;
	}
	public File getYxyaddr() {
		return yxyaddr;
	}
	public void setYxyaddr(File yxyaddr) {
		this.yxyaddr = yxyaddr;
	}
	public String getAddrfilename() {
		return addrfilename;
	}
	public void setAddrfilename(String addrfilename) {
		this.addrfilename = addrfilename;
	}
	public int getResult() {
		return result;
	}
	public void setResult(int result) {
		this.result = result;
	}
	public int getTypeid() {
		return typeid;
	}
	public void setTypeid(int typeid) {
		this.typeid = typeid;
	}
	public Map<String, List<String>> getErromap() {
		return erromap;
	}
	public void setErromap(Map<String, List<String>> erromap) {
		this.erromap = erromap;
	}
	public int getUploadtype() {
		return uploadtype;
	}
	public void setUploadtype(int uploadtype) {
		this.uploadtype = uploadtype;
	}
	public String getUploademail() {
		return uploademail;
	}
	public void setUploademail(String uploademail) {
		this.uploademail = uploademail;
	}
	public int getFilterid() {
		return filterid;
	}
	public void setFilterid(int filterid) {
		this.filterid = filterid;
	}
	public String getContext() {
		return context;
	}
	public void setContext(String context) {
		this.context = context;
	}
	public String getTimestr() {
		return timestr;
	}
	public void setTimestr(String timestr) {
		this.timestr = timestr;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public int getIsmanytitle() {
		return ismanytitle;
	}
	public void setIsmanytitle(int ismanytitle) {
		this.ismanytitle = ismanytitle;
	}
	public String getLinkadderss() {
		return linkadderss;
	}
	public void setLinkadderss(String linkadderss) {
		this.linkadderss = linkadderss;
	}
	public String getAttrpath() {
		return attrpath;
	}
	public void setAttrpath(String attrpath) {
		this.attrpath = attrpath;
	}
	public String getEmailreg() {
		return emailreg;
	}
	public Map<String, String> getImportaddress() {
		return importaddress;
	}
	public void setImportaddress(Map<String, String> importaddress) {
		this.importaddress = importaddress;
	}
	public String getTxtfilename() {
		return txtfilename;
	}
	public void setTxtfilename(String txtfilename) {
		this.txtfilename = txtfilename;
	}
	public int getMailid() {
		return mailid;
	}
	public void setMailid(int mailid) {
		this.mailid = mailid;
	}
	public int getSendci() {
		return sendci;
	}
	public void setSendci(int sendci) {
		this.sendci = sendci;
	}
	public String getSender() {
		return sender;
	}
	public void setSender(String sender) {
		this.sender = sender;
	}
	public String getReplyemail() {
		return replyemail;
	}
	public void setReplyemail(String replyemail) {
		this.replyemail = replyemail;
	}
	public int getUnlanguage() {
		return unlanguage;
	}
	public void setUnlanguage(int unlanguage) {
		this.unlanguage = unlanguage;
	}
	public String getUnselfstr() {
		return unselfstr;
	}
	public void setUnselfstr(String unselfstr) {
		this.unselfstr = unselfstr;
	}
	public int getMainid() {
		return mainid;
	}
	public void setMainid(int mainid) {
		this.mainid = mainid;
	}
	public YxyCustomerService getCustomerservice() {
		return customerservice;
	}
	public void setCustomerservice(YxyCustomerService customerservice) {
		this.customerservice = customerservice;
	}
	public YxyReadingInfoService getYxyreadinginfoservice() {
		return yxyreadinginfoservice;
	}
	public void setYxyreadinginfoservice(YxyReadingInfoService yxyreadinginfoservice) {
		this.yxyreadinginfoservice = yxyreadinginfoservice;
	}
	public int getJinchengid() {
		return jinchengid;
	}
	public void setJinchengid(int jinchengid) {
		this.jinchengid = jinchengid;
	}
	public String getCustomerid() {
		return customerid;
	}
	public void setCustomerid(String customerid) {
		this.customerid = customerid;
	}
}