preuser.cc

可以对从数据库导出的数据文件进行纠错处理

	time(&end);
	rlogit(PREUSER_ERR(1000), "cust write [%d] use time [%d].", iLineNo, end - start);
	rlogit(PREUSER_ERR(1000), "客户资料预处理完成.");
}

// acct信息预处理
void preAcctInfo()
{
	static const char* func = "preAcctInfo";
	
	char		strBuff[LINE_MAX_LEN];
	char		*strLine;
	FILE		*streamIn, *streamErr, *streamOut, *streamSrcOut;
	TSet		setDup;
	TAcctMap	mapAcct;
	TAcctMapit	mapIt;
	int			seq_nbr, old_seq_nbr;
	int			iLineNo;
	time_t		start, end;
	
	// 打开帐户资料文件
	streamIn = fopen64(mapFileDir["acct_in"].c_str(), "r");
	if (streamIn == NULL)
	{
		rlogit(PREUSER_ERR(-13), "Could not open file [%s].", mapFileDir["acct_in"].c_str());
		return;
	}
	// 打开错单文件
	streamErr = fopen(mapFileDir["acct_err"].c_str(), "w");
	if (streamErr == NULL)
	{
		rlogit(PREUSER_ERR(-14), "Could not open file [%s].", mapFileDir["acct_err"].c_str());
		return;
	}
	iLineNo = 0;
	time(&start);
	// 读帐户资料文件
	while(!feof(streamIn))
	{
		memset(strBuff, 0, LINE_MAX_LEN);
		iLineNo++;
		if(fgets(strBuff, LINE_MAX_LEN, streamIn) == NULL) continue;
		if(strlen(strBuff) == LINE_MAX_LEN - 1)
		{
			fclose(streamIn);
			fclose(streamErr);
			rlogit(PREUSER_ERR(-15), "file [%s] line [%d] is too long.", mapFileDir["acct_in"].c_str(), iLineNo);
			return;
		}
		
		strLine = trim(strBuff);
		
		if(strlen(strLine) == 0) continue;
		
		if( judgeError(strLine, 3) == 0 )
		{
			// 查重
			setDup.insert(TSettype(strLine));
		}
		else
		{
			// 写错单文件
			fprintf(streamErr, "%s\n", strLine);
			fflush(streamErr);
		}
	}
	fclose(streamIn);
	fclose(streamErr);
	time(&end);
	rlogit(PREUSER_ERR(1000), "acct check dup and correct error [%d] use time [%d].", iLineNo, end - start);
	
	time(&start);
	// 帐户资料过滤
	for(TSetit it = setDup.begin(); it != setDup.end(); it++)
	{
		// 获取帐户信息
		TVector acct;
		
		getAcctInfo(*it, acct);
		
		// 在帐户信息表中查找
		mapIt = mapAcct.find(acct[ACCT_ACCT_ID_POS]);
		if( mapIt != mapAcct.end() )
		{
			// 已经存在此帐户信息
			seq_nbr = atoi(acct[ACCT_SEQ_NBR_POS].c_str());
			old_seq_nbr = atoi(mapIt->second[ACCT_SEQ_NBR_POS].c_str());
			// 比较序列号，将最大的插入帐户结构中
			if (seq_nbr > old_seq_nbr)
			{						
				mapAcct.erase(mapIt);
				mapAcct.insert(TAcctMaptype(acct[ACCT_ACCT_ID_POS], acct));
			}
		}
		else
		{
			// 无此帐户信息
			mapAcct.insert(TAcctMaptype(acct[ACCT_ACCT_ID_POS], acct));
		}
	}
	setDup.clear();
	
	time(&end);
	rlogit(PREUSER_ERR(1000), "acct filter [%d] use time [%d].", iLineNo, end - start);
	
	time(&start);
	// 打开帐户资料输出文件
	streamOut = fopen64(mapFileDir["acct_out"].c_str(), "w");
	if (streamOut == NULL)
	{
		rlogit(PREUSER_ERR(-16), "Could not open file [%s].", mapFileDir["acct_out"].c_str());
		return;
	}
	
	// 打开帐户原始资料输出文件
	streamSrcOut = fopen64(mapFileDir["acct_src_out"].c_str(), "w");
	if (streamSrcOut == NULL)
	{
		rlogit(PREUSER_ERR(-16), "Could not open file [%s].", mapFileDir["acct_src_out"].c_str());
		return;
	}
	
	// 将纠错、查重、过滤后的帐户资料保存到文件中
	for(TAcctMapit it = mapAcct.begin(); it != mapAcct.end(); it++)
	{
		// 写扩充后的客户资料表
		string	strAcctTemp;
		
		for(TVecIt vecIt = it->second.begin(); vecIt != it->second.end(); vecIt++)
		{
			strAcctTemp.append(*vecIt).append("|");
		}
		
		fprintf(streamSrcOut, "%s\n", strAcctTemp.c_str());
		fflush(streamSrcOut);
		
		char	strTemp[FILTER_LINE_LEN];
		memset(strTemp, 0, sizeof(strTemp));
		
		snprintf(strTemp, FILTER_LINE_LEN, "%s|%s|%s|%s|", 
									it->second[ACCT_ACCT_ID_POS].c_str(),
									it->second[ACCT_ACCT_NAME_POS].c_str(),
									it->second[ACCT_PAYMENT_METHOD_POS].c_str(),
									it->second[ACCT_SITE_ID_POS].c_str());
		fprintf(streamOut, "%s\n", strTemp);
		fflush(streamOut);
	}
	fclose(streamSrcOut);
	fclose(streamOut);
	mapAcct.clear();
	
	time(&end);
	rlogit(PREUSER_ERR(1000), "acct write [%d] use time [%d].", iLineNo, end - start);
	rlogit(PREUSER_ERR(1000), "帐户资料预处理完成.", iLineNo, end - start);
}

// serv_acct信息预处理
void preServAcctInfo()
{
	static const char* func = "preServAcctInfo";
	
	char			strBuff[LINE_MAX_LEN];
	char			*strLine;
	FILE			*streamIn, *streamErr, *streamOut;
	TServAcct		serv_acct;
	TSet			setDup;
	TServAcctMap	mapServAcct;
	TServAcctMapit	mapServAcctIt;
	int				seq_nbr, old_seq_nbr;
	int				iLineNo;
	time_t			start, end;
	
	// 打开帐务关系数据文件
	streamIn = fopen64(mapFileDir["serv_acct_in"].c_str(), "r");
	if (streamIn == NULL)
	{
		rlogit(PREUSER_ERR(-17), "Could not open file [%s].", mapFileDir["serv_acct_in"].c_str());
		return;
	}
	// 打开错单文件
	streamErr = fopen(mapFileDir["serv_acct_err"].c_str(), "w");
	if (streamErr == NULL)
	{
		rlogit(PREUSER_ERR(-18), "Could not open file [%s].", mapFileDir["serv_acct_err"].c_str());
		return;
	}
	
	iLineNo = 0;
	time(&start);
	// 读帐务关系数据文件
	while(!feof(streamIn))
	{
		memset(strBuff, 0, LINE_MAX_LEN);
		iLineNo++;
		if(fgets(strBuff, LINE_MAX_LEN, streamIn) == NULL) continue;
		if(strlen(strBuff) == LINE_MAX_LEN - 1)
		{
			fclose(streamIn);
			fclose(streamErr);
			rlogit(PREUSER_ERR(-19), "file [%s] line [%d] is too long.", mapFileDir["serv_acct_in"].c_str(), iLineNo);
			return;
		}
		
		strLine = trim(strBuff);
		
		if(strlen(strLine) == 0) continue;
		
		if( judgeError(strLine, 4) == 0 )
		{
			// 查重
			setDup.insert(TSettype(strLine));
		}
		else
		{
			// 写错单文件
			fprintf(streamErr, "%s\n", strLine);
			fflush(streamErr);
		}
	}
	fclose(streamIn);
	fclose(streamErr);
	time(&end);
	rlogit(PREUSER_ERR(1000), "serv_acct check dup and correct error [%d] use time [%d].", iLineNo, end - start);
	
	time(&start);
	// 帐户资料过滤
	for(TSetit it = setDup.begin(); it != setDup.end(); it++)
	{
		// 获取帐户信息
		getServAcctInfo(*it, &serv_acct);
		
		if(atoi(serv_acct.acct_item_type_id) == -1)
		{
			// 在帐务关系表中查找
			mapServAcctIt = mapServAcct.find(serv_acct.serv_id);
			if( mapServAcctIt != mapServAcct.end() )
			{
				// 已经存在此帐户信息
				seq_nbr = atoi(serv_acct.seq_nbr);
				old_seq_nbr = atoi(mapServAcctIt->second.seq_nbr);
				// 比较序列号，将最大的插入帐务信息结构中
				if (seq_nbr > old_seq_nbr)
				{						
					mapServAcct.erase(mapServAcctIt);
					mapServAcct.insert(TServAcctMaptype(serv_acct.serv_id, serv_acct));
				}
			}
			else
			{
				// 无此帐务关系信息
				mapServAcct.insert(TServAcctMaptype(serv_acct.serv_id, serv_acct));
			}
		}
	}
	setDup.clear();
	
	time(&end);
	rlogit(PREUSER_ERR(1000), "serv_acct filter [%d] use time [%d].", iLineNo, end - start);
	
	time(&start);
	// 打开帐务关系表输出文件
	streamOut = fopen64(mapFileDir["serv_acct_out"].c_str(), "w");
	if (streamOut == NULL)
	{
		rlogit(PREUSER_ERR(-20), "Could not open file [%s].", mapFileDir["serv_acct_out"].c_str());
		return;
	}
	
	// 将纠错、查重、过滤后的帐务关系数据保存到文件中
	for(TServAcctMapit it = mapServAcct.begin(); it != mapServAcct.end(); it++)
	{
		char	strTemp[FILTER_LINE_LEN];
		memset(strTemp, 0, sizeof(strTemp));
		
		snprintf(strTemp, FILTER_LINE_LEN, "%s|%s|", 
									it->second.serv_id,
									it->second.acct_id);
		fprintf(streamOut, "%s\n", strTemp);
		fflush(streamOut);
	}
	fclose(streamOut);
	mapServAcct.clear();
	
	time(&end);
	rlogit(PREUSER_ERR(1000), "serv_acct write [%d] use time [%d].", iLineNo, end - start);
	rlogit(PREUSER_ERR(1000), "帐务关系预处理完成.", iLineNo, end - start);
}

// serv_product信息预处理
void preServProdInfo()
{
	static const char* func = "preServProdInfo";
	
	char			strBuff[LINE_MAX_LEN];
	char			*strLine;
	FILE			*streamIn, *streamErr, *streamOut;
	TServProd		serv_prod;
	TSet			setDup;
	TServProdMap	mapServProd;
	TServProdMapit	mapServProdIt;
	int				seq_nbr, old_seq_nbr;
	int				iLineNo;
	time_t			start, end;
	
	// 打开占用资源表文件
	streamIn = fopen64(mapFileDir["serv_prod_in"].c_str(), "r");
	if (streamIn == NULL)
	{
		rlogit(PREUSER_ERR(-21), "Could not open file [%s].", mapFileDir["serv_prod_in"].c_str());
		return;
	}
	// 打开错单文件
	streamErr = fopen(mapFileDir["serv_prod_err"].c_str(), "w");
	if (streamErr == NULL)
	{
		rlogit(PREUSER_ERR(-22), "Could not open file [%s].", mapFileDir["serv_prod_err"].c_str());
		return;
	}
	iLineNo = 0;
	time(&start);
	// 读帐户资料文件
	while(!feof(streamIn))
	{
		memset(strBuff, 0, LINE_MAX_LEN);
		iLineNo++;
		if(fgets(strBuff, LINE_MAX_LEN, streamIn) == NULL) continue;
		if(strlen(strBuff) == LINE_MAX_LEN - 1)
		{
			fclose(streamIn);
			fclose(streamErr);
			rlogit(PREUSER_ERR(-23), "file [%s] line [%d] is too long.", mapFileDir["serv_prod_in"].c_str(), iLineNo);
			return;
		}
		
		strLine = trim(strBuff);
		
		if(strlen(strLine) == 0) continue;
		
		if( judgeError(strLine, 5) == 0 )
		{
			// 查重
			setDup.insert(TSettype(strLine));
		}
		else
		{
			// 写错单文件
			fprintf(streamErr, "%s\n", strLine);
			fflush(streamErr);
		}
	}
	fclose(streamIn);
	fclose(streamErr);
	time(&end);
	rlogit(PREUSER_ERR(1000), "serv_product check dup and correct error [%d] use time [%d].", iLineNo, end - start);
	
	time(&start);
	// 占用资源过滤
	for(TSetit it = setDup.begin(); it != setDup.end(); it++)
	{
		// 获取占用资源信息
		getServProdInfo(*it, &serv_prod);
		
		// 在占用资源信息表中查找
		mapServProdIt = mapServProd.find(serv_prod.serv_id);
		if( mapServProdIt != mapServProd.end() )
		{
			// 已经存在此占用资源信息
			seq_nbr = atoi(serv_prod.seq_nbr);
			old_seq_nbr = atoi(mapServProdIt->second.seq_nbr);
			// 比较序列号，将最大的插入帐户结构中
			if (seq_nbr > old_seq_nbr)
			{						
				mapServProd.erase(mapServProdIt);
				mapServProd.insert(TServProdMaptype(serv_prod.serv_id, serv_prod));
			}
		}
		else
		{
			// 无此占用资源信息
			mapServProd.insert(TServProdMaptype(serv_prod.serv_id, serv_prod));
		}
	}
	setDup.clear();
	
	time(&end);
	rlogit(PREUSER_ERR(1000), "serv_product filter [%d] use time [%d].", iLineNo, end - start);
	
	time(&start);
	// 打开占用资源输出文件
	streamOut = fopen64(mapFileDir["serv_prod_out"].c_str(), "w");
	if (streamOut == NULL)
	{
		rlogit(PREUSER_ERR(-24), "Could not open file [%s].", mapFileDir["serv_prod_out"].c_str());
		return;
	}
	
	// 将纠错、查重、过滤后的占用资源资料保存到文件中
	for(TServProdMapit it = mapServProd.begin(); it != mapServProd.end(); it++)
	{
		char	strTemp[FILTER_LINE_LEN];
		memset(strTemp, 0, sizeof(strTemp));
		
		snprintf(strTemp, FILTER_LINE_LEN, "%s|%s|%s|", 
									it->second.serv_id,
									it->second.product_id,
									it->second.product_quantity);
		fprintf(streamOut, "%s\n", strTemp);
		fflush(streamOut);
	}
	fclose(streamOut);
	mapServProd.clear();
	
	time(&end);
	rlogit(PREUSER_ERR(1000), "serv_product write [%d] use time [%d].", iLineNo, end - start);
	rlogit(PREUSER_ERR(1000), "占用资源资料预处理完成.", iLineNo, end - start);
}

// 信息纠错
int judgeError(const char* strLine, int iFlag)
{
	char*	pToken;
	char	strTemp[LINE_MAX_LEN];
	int		iFieldCount;
	
	strTemp[0] = 0;
	iFieldCount = 0;
	
	snprintf(strTemp, sizeof(strTemp), "%s", strLine);
	
	pToken = strTemp;
	while(1)
	{
		pToken = strchr(pToken, '|');
		if ( pToken == NULL ) break;
		iFieldCount++;
		pToken++;
	}

	switch(iFlag)
	{
		case 1:
			if ( iFieldCount != SERV_FIELD_COUNT ) return -1;
			break;
		case 2:
			if ( iFieldCount != CUST_FIELD_COUNT ) return -2;
			break;	
		case 3:
			if ( iFieldCount != ACCT_FIELD_COUNT ) return -3;
			break;
		case 4:
			if ( iFieldCount != SERV_ACCT_FIELD_COUNT ) return -4;
			break;
		case 5:
			if ( iFieldCount != SERV_PRODUCT_FIELD_COUNT ) return -5;
			break;
	}
	return 0;
}

// 获得用户信息
void getServInfo(const string& strServ, TVector& serv)
{
	char*	pToken;
	char*	pTemp;
	char	strTemp[LINE_MAX_LEN];
	char	strBuf[2];
	
	strBuf[0] = 0;
	strTemp[0] = 0;

	snprintf(strTemp, LINE_MAX_LEN, "%s", strServ.c_str());

	pToken = strTemp;
	
	srand( (unsigned)time( NULL ) );
	
	serv.clear();
	
	while(1)
	{
		pTemp = pToken;
		pToken = strchr(pToken, '|');
		if ( pToken == NULL ) break;
		*pToken++ = 0;
		
		serv.push_back(TVecType(pTemp));
	}
	// 随机生成客户标识
	snprintf(strBuf, 2, "%d", (rand() % 4) + 1);
	serv.push_back(TVecType(strBuf));
}

// 获得客户信息
void getCustInfo(const string& strCust, TVector& cust)
{
	char*	pToken;
	char*	pTemp;
	char	strTemp[LINE_MAX_LEN];
	
	strTemp[0] = 0;
	
	snprintf(strTemp, LINE_MAX_LEN, "%s", strCust.c_str());
	
	pToken = strTemp;
	while(1)
	{
		pTemp = pToken;
		pToken = strchr(pToken, '|');
		if ( pToken == NULL ) break;
		*pToken++ = 0;
		
		cust.push_back(TVecType(pTemp));
	}
}

// 获得帐户信息
void getAcctInfo(const string& strAcct, TVector& acct)
{
	char*	pToken;
	char*	pTemp;
	char	strTemp[LINE_MAX_LEN];
	
	strTemp[0] = 0;
	
	snprintf(strTemp, LINE_MAX_LEN, "%s", strAcct.c_str());		

	pToken = strTemp;