do_portfolio.cpp

股票分析源代码

		config_file_map.load_file(str_config_file_name.c_str());		
	}		
	
	PflSumDataPtr pfl_sum_data_ptr;	
	VectPflDataPtr vect_pfl_data_ptr;
	MapPflSumData::const_iterator iter;
	
	string str_title_key = "title";
	string str_section = "w";
	VectConfigFileItem vect_item;
	
	for (iter=map_data.begin();iter != map_data.end();iter++)
	{
		pfl_sum_data_ptr = iter->second;
		vect_pfl_data_ptr = pfl_sum_data_ptr->vect_pfl_data_ptr;
		
		if (vect_pfl_data_ptr->size() == 0)
		{
			//cout << "no stock to find" << endl;
			continue;
		}
	
		bool is_found = false;
		for (unsigned int j=0;j<vect_pfl_data_ptr->size();j++)
		{			
			if (is_only_include_selected_data && !(*vect_pfl_data_ptr)[j].is_selected)
			{
				continue;	
			}
			
			str_section = string("pfl_") + (*vect_pfl_data_ptr)[j].selector_name;
			config_file_map.get_section_items(vect_item,str_section);
			if (vect_item.size() > 1)
			{
				stable_sort(vect_item.begin(),
					vect_item.end(),gnu::ConfigFileItemSort_key);
				
			}
				
			is_found = false;
			for (unsigned int i=0;i<vect_item.size();i++)
			{
				if (str_trim(vect_item[i].value) == str_trim((*vect_pfl_data_ptr)[j].code))
				{
					is_found = true;
					break;
				}
			} // for (unsigned int i=0;i<vect_item.size();i++)
			
			if (is_found)
			{
				//cout << "found stock : " <<  (*vect_selectordata_ptr)[j].code << endl;
				I18N_DEBUG(_("%s [%s:%l] found stock : %s in %s group, don't need to insert.\n"),
					(*vect_pfl_data_ptr)[j].code,
					(*vect_pfl_data_ptr)[j].selector_title);
				continue;
			} else
			{
				I18N_DEBUG(_("%s [%s:%l] insert stock : %s into : %s group.\n"),
					(*vect_pfl_data_ptr)[j].code,
					(*vect_pfl_data_ptr)[j].selector_title);
			}		
			
			str_key = "w";			
			get_last_cmb_key(str_key,vect_item.size());
			str_value = str_trim((*vect_pfl_data_ptr)[j].code);
			
			isTrue = config_file_map.set_value(str_section,str_key,str_value);
			if (!isTrue)
			{
				I18N_ERROR(_("%s [%s:%l] Can't set section : %s, key : %s value : %s.\n"),
					str_section.c_str(),str_key.c_str(),str_value.c_str());					
			}			
			
		} // for (unsigned int j=0;j<vect_selectordata_ptr->size();j++)		
		
	} //for (iter=map_data.begin();iter != map_data.end();iter++)
	
	isTrue = config_file_map.save();
	if (!isTrue)
	{
		I18N_ERROR(_("%s [%s:%l] Can't save pfl_data_file : %s.\n"),str_config_file_name.c_str());			
	}
}

void hbstock2::write_self_pfl_stocks(const std::map<int,VectSelectorDataPtr>& map_data)
{
	bool isTrue = false;
	bool is_write_self_stocks = true;
	
	// get config of is_write_self_stocks
	string str_key = "is_write_self_stocks";
	string str_value = "w";
	int i_value = 0;
	
	AppConfig* p_app_config = AppConfigInst::instance();
	isTrue = p_app_config->get_value(str_key,i_value);
	if (!isTrue)
	{
		I18N_DEBUG(_("%s [%s:%l] Don't find key : is_write_self_stocks in config file, now insert it.\n"));
		i_value = 1;
		p_app_config->set_value(str_key,i_value);
	}
	
	if (i_value == 0)
	{
		is_write_self_stocks = false;
	} else
	{
		is_write_self_stocks = true;
	}
			
	if (!is_write_self_stocks)
	{
		return;
	}
	
	str_key = "pfl_data_file";	
	string str_config_file_name = "w";
	
	isTrue = p_app_config->get_value(str_key,str_value);
	if (!isTrue)
	{
		I18N_DEBUG(_("%s [%s:%l] Don't find key : pfl_data_file in config file, now insert it.\n"));
		str_value = "pfl_self.conf";
		p_app_config->set_value(str_key,str_value);
	}
	
	str_config_file_name = p_app_config->get_root_dir() + "/etc/" + str_value;
	
	ConfigFileMap config_file_map;
	
	isTrue = config_file_map.load_file(str_config_file_name.c_str());
	if (!isTrue)
	{
		//I18N_ERROR(_("%s [%s:%l] Can't open pfl_data_file : %s, system exit.\n"),str_config_file_name.c_str());		
		create_pfl_config_file(str_config_file_name.c_str());
		config_file_map.load_file(str_config_file_name.c_str());		
	}		
	
	VectSelectorDataPtr vect_selectordata_ptr;
	std::map<int,VectSelectorDataPtr>::const_iterator iter;
	
	string str_title_key = "title";
	string str_section = "w";
	VectConfigFileItem vect_item;
	
	for (iter=map_data.begin();iter != map_data.end();iter++)
	{
		vect_selectordata_ptr = iter->second;
		if (vect_selectordata_ptr->size() == 0)
		{
			//cout << "no stock to find" << endl;
			continue;
		}
		
		str_section = string("pfl_") + (*vect_selectordata_ptr)[0].selector_name;
		// set title
		isTrue = config_file_map.get_value(str_section,str_title_key,str_value);
		if (!isTrue)
		{			
			str_value = (*vect_selectordata_ptr)[0].selector_title;
			isTrue = config_file_map.set_value(str_section,str_title_key,str_value);
		}
		
		
		config_file_map.get_section_items(vect_item,str_section);
		if (vect_item.size() > 1)
		{
			stable_sort(vect_item.begin(),
				vect_item.end(),gnu::ConfigFileItemSort_key);			
		}		
		
		bool is_found = false;
		for (unsigned int j=0;j<vect_selectordata_ptr->size();j++)
		{
			is_found = false;
			for (unsigned int i=0;i<vect_item.size();i++)
			{
				if (str_trim(vect_item[i].value) == str_trim((*vect_selectordata_ptr)[j].code))
				{
					is_found = true;
					break;
				}
			} // for (unsigned int i=0;i<vect_item.size();i++)
			
			if (is_found)
			{
				//cout << "found stock : " <<  (*vect_selectordata_ptr)[j].code << endl;
				I18N_DEBUG(_("%s [%s:%l] found stock : %s in %s group, don't need to insert.\n"),
					(*vect_selectordata_ptr)[j].code,
					(*vect_selectordata_ptr)[j].selector_title);
				continue;
			} else
			{
				I18N_DEBUG(_("%s [%s:%l] insert stock : %s into : %s group.\n"),
					(*vect_selectordata_ptr)[j].code,
					(*vect_selectordata_ptr)[j].selector_title);
			}		
			
			get_last_cmb_key(str_key,vect_item.size());
			str_value = str_trim((*vect_selectordata_ptr)[j].code);
			
			isTrue = config_file_map.set_value(str_section,str_key,str_value);
			if (!isTrue)
			{
				I18N_ERROR(_("%s [%s:%l] Can't set section : %s, key : %s value : %s.\n"),
					str_section.c_str(),str_key.c_str(),str_value.c_str());					
			}				
			
		} // for (unsigned int j=0;j<vect_selectordata_ptr->size();j++)		
		
	} //for (iter=map_data.begin();iter != map_data.end();iter++)
	
	isTrue = config_file_map.save();
	if (!isTrue)
	{
		I18N_ERROR(_("%s [%s:%l] Can't save pfl_data_file : %s.\n"),str_config_file_name.c_str());			
	}
}

void hbstock2::obtain_pfl_data_from_file(
	MapPflSumData& map_pfl_sum_data,
	const VectPflFileData& vect_pfl_file_data,
	const char* p_ch_date)
{
	// init pfl sum data
	init_map_pfl_sum_data(map_pfl_sum_data,true,p_ch_date);
	
	DataManger* p_datamanger = DataMangerInst::instance();
		
	// copy selector data to pfl data
	VectPflFileData::const_iterator iter;
	VectConfigFileItemPtr vect_item_ptr;
	PflSumDataPtr pfl_sum_data_temp_ptr;
	
	std::string str_stock_code_out = "w";
	std::string str_market_code = "w";
	bool isTrue = false;
	
	for (iter=vect_pfl_file_data.begin();iter != vect_pfl_file_data.end();iter++)
	{	
		if (! iter->is_selected)
		{
			continue;
		}
		
		vect_item_ptr = iter->vect_item_ptr;			
				
		for (unsigned int i=0;i<vect_item_ptr->size();i++)
		{
			PflData pfl_data;
			
			pfl_data.period_type = SHORT_LINE;
			strcpy(pfl_data.code,(*vect_item_ptr)[i].value.c_str());	
			strcpy(pfl_data.selector_name,(*iter).name.c_str());	
			strcpy(pfl_data.selector_title,(*iter).title.c_str());	
			
			// add pfl_data to map
			
			isTrue = p_datamanger->check_transform_stock_code(pfl_data.code,
				str_stock_code_out,
				str_market_code);
			if (!isTrue)
			{
				I18N_ERROR(_("%s [%s:%l] Don't find stock : %s \n"),pfl_data.code);
				continue;
			}
			
			if (pfl_data.code[0] >= '0' && pfl_data.code[0]<='9')
			{
				str_stock_code_out = str_market_code + "." + string(pfl_data.code);
				strcpy(pfl_data.code,str_stock_code_out.c_str());	
			}
						
			//find pfl_sum_data
			//pfl_sum_data_temp_ptr = map_pfl_sum_data[str_market_code];
			pfl_sum_data_temp_ptr = find_map_pfl_sum_data(gnu::str_toupper(str_market_code),
				map_pfl_sum_data);	
			if (pfl_sum_data_temp_ptr.get() == NULL)
			{
				continue;
			}
			
			// test if found in vect_pfl_data
			bool is_found = false;
			is_found =binary_search(pfl_sum_data_temp_ptr->vect_pfl_data_ptr->begin(),
				pfl_sum_data_temp_ptr->vect_pfl_data_ptr->end(),
				pfl_data,hbstock2::PflDataSort);
			if (!is_found)
			{
				pfl_sum_data_temp_ptr->vect_pfl_data_ptr->push_back(pfl_data);
				//pfl_data_source.vect_cmb_init_stock.push_back(cmb_init_stock);
				stable_sort(pfl_sum_data_temp_ptr->vect_pfl_data_ptr->begin(),
					pfl_sum_data_temp_ptr->vect_pfl_data_ptr->end(),
					hbstock2::PflDataSort);
			}			
			
		} //for (unsigned int i=0;i<vect_stock_ptr->size();i++)
	} // for (iter=vect_pfl_file_data.begin();iter != vect_pfl_file_data.end();iter++)
	
}

PflSumDataPtr hbstock2::find_map_pfl_sum_data(const std::string& str_market_code,
	const MapPflSumData& map_pfl_sum_data)
{	
	MapPflSumData::const_iterator iter;
	PflSumDataPtr pfl_sum_data_ptr;	
	std::vector<std::string> vect_split;
	
	for (iter=map_pfl_sum_data.begin();iter != map_pfl_sum_data.end();iter++)
	{	
		vect_split.clear();
		gnu::str_split(iter->first.c_str(),",",vect_split);
		for (unsigned int i=0;i<vect_split.size();i++)
		{
			if (vect_split[i] == str_market_code)
			{
				pfl_sum_data_ptr = iter->second;
				break;
			}
		} //for (unsigned int i=0;i<vect_split.size();i++)		
	} //for (iter=map_pfl_sum_data.begin();iter != map_pfl_sum_data.end();iter++)
	
	return pfl_sum_data_ptr;
}

void hbstock2::init_map_pfl_sum_data(MapPflSumData& map_pfl_sum_data,
	const bool is_user_defined_type,
	const char* p_ch_date)
{
	map_pfl_sum_data.clear();
	
	// get time
	char p_ch_date_tmp[256];
	struct tm* p_tm_now = NULL;
	time_t tt_now = 0;
	
	memset(p_ch_date_tmp,'\0',sizeof(p_ch_date_tmp));
	
	if (p_ch_date != NULL)
	{
		strcpy(p_ch_date_tmp,p_ch_date);
	} else
	{
		tt_now = time(NULL);
		p_tm_now = localtime(&tt_now);
		strftime(p_ch_date_tmp ,sizeof(p_ch_date_tmp)-1 , "%Y%m%d",p_tm_now);
	}
	
	//check is sum market
	//China Market:SH.000001:sh,sz:1
	string str_market_title = _("ShangHai,ShenZhen");
	string str_market_combine = str_market_title + ":SH.000001:SH,SZ:1";
	
	AppConfig* p_app_config = AppConfigInst::instance();
	string str_section = "general";
	string str_key = "pfl_market_combine";
	string str_value = "w";
	p_app_config->get_value(str_section,str_key,str_value,str_market_combine);
	
	std::vector<std::string> vect_split;
	std::vector<std::string> vect_split_sub;	
	gnu::str_split(str_value.c_str(),";",vect_split);
	for (unsigned int i=0;i<vect_split.size();i++)
	{
		gnu::str_split(vect_split[i].c_str(),":",vect_split_sub);
		if (vect_split_sub.size()!=4)
		{
			I18N_ERROR(_("%s [%s:%l] pfl_market_combine format : %s error.\n"),vect_split[i].c_str());	
			continue;
		}
		
		int i_pfl_combine = atoi(vect_split_sub[3].c_str());
		if (i_pfl_combine == 0)
		{
			I18N_DEBUG(_("%s [%s:%l] don't need market combine.\n"));	
			continue;
		}
		
		PflSumDataPtr pfl_sum_data_ptr(new PflSumData);
		
		// for selector selected stock
		pfl_sum_data_ptr->is_user_defined_type = is_user_defined_type;
		strcpy(pfl_sum_data_ptr->market_code,str_toupper(vect_split_sub[2]).c_str());
		strcpy(pfl_sum_data_ptr->market_title,vect_split_sub[0].c_str());
		strcpy(pfl_sum_data_ptr->index_code,str_toupper(vect_split_sub[1]).c_str());
		
		map_pfl_sum_data[pfl_sum_data_ptr->market_code] = pfl_sum_data_ptr;		
		if (p_ch_date != NULL)
		{
			strcpy(pfl_sum_data_ptr->input_day,p_ch_date);
		} else
		{
			strcpy(pfl_sum_data_ptr->input_day,p_ch_date_tmp);
		}
		
	} //for (unsigned int i=0;i<vect_split.size();i++)
	
	// init pfl sum data
	SetMarket::iterator iter_market;
	DataManger* p_datamanger = NULL;
	p_datamanger = DataMangerInst::instance();
	SetMarketPtr set_market_ptr;
	PflSumDataPtr pfl_sum_data_temp_ptr;
	set_market_ptr = p_datamanger->get_all_market();
	for (iter_market=set_market_ptr->begin();iter_market !=  set_market_ptr->end();iter_market++)
	{
		//find pfl_sum_data			
		pfl_sum_data_temp_ptr = find_map_pfl_sum_data(gnu::str_toupper(iter_market->code),
			map_pfl_sum_data);	
		if (pfl_sum_data_temp_ptr.get() != NULL)
		{
				continue;
		}
		
		PflSumDataPtr pfl_sum_data_ptr(new PflSumData);
		
		// for selector selected stock
		pfl_sum_data_ptr->is_user_defined_type = is_user_defined_type;
		strcpy(pfl_sum_data_ptr->market_code,iter_market->code.c_str());
		strcpy(pfl_sum_data_ptr->market_title,iter_market->title.c_str());
		map_pfl_sum_data[iter_market->code] = pfl_sum_data_ptr;		
		if (p_ch_date != NULL)
		{
			strcpy(pfl_sum_data_ptr->input_day,p_ch_date);
		} else
		{
			strcpy(pfl_sum_data_ptr->input_day,p_ch_date_tmp);
		}
	}	
}

void hbstock2::obtain_pfl_data(MapPflSumData& map_pfl_sum_data,
	const std::map<int,VectSelectorDataPtr>& map_data,
	const char* p_ch_date)
{	
	// init pfl sum data
	init_map_pfl_sum_data(map_pfl_sum_data,false,p_ch_date);
	
	// copy selector data to pfl data
	std::map<int,VectSelectorDataPtr>::const_iterator iter;
	VectSelectorDataPtr vect_selectordata_ptr;
	PflSumDataPtr pfl_sum_data_temp_ptr;
	
	for (iter=map_data.begin();iter != map_data.end();iter++)
	{		
		vect_selectordata_ptr = iter->second;			
				
		for (unsigned int i=0;i<vect_selectordata_ptr->size();i++)
		{
			PflData pfl_data;
			
			pfl_data.period_type = (*vect_selectordata_ptr)[i].period_type;
			strcpy(pfl_data.code,(*vect_selectordata_ptr)[i].code);	
			strcpy(pfl_data.selector_name,(*vect_selectordata_ptr)[i].selector_name);	
			strcpy(pfl_data.selector_title,(*vect_selectordata_ptr)[i].selector_title);