/****************************************************************/
/*																*/
/*  ApplicationDlg.cpp											*/
/*																*/
/*  Implementation of the CDBServerDlg class.				*/
/*	This class is a part of the Date Server.						*/
/*																*/
/*  Programmed by LYFZ van der Meer							*/
/*  Copyright LYFZ Software Solutions 2002						*/
/*	http://www.LYFZvandermeer.nl								*/
/*																*/
/*  Last updated: 10 july 2002									*/
/*																*/
/****************************************************************/
//在ApplicationDlg.cpp文件中实现主窗口界面的设计。及其主窗口相应控件的功能和参数的映射。

#include "stdafx.h"
#include "DBServer.h"
#include "theDBServer.h"
#include "DBServerDlg.h"
#include "UserAccountsDlg.h"
#include "WizardPages.h"
#include "AboutDlg.h"
#include <afxpriv.h>
#include <process.h>
#include "Shlwapi.h"
#include "MyLock.h"
#include "mysqldata.h"
//#include "./helper/ffsco.h"
#include <tlhelp32.h>
#include "my32.h"
#include "SoftKey.h"
#include "DogTimeOutDlg.h"
#include "InputAuthDlg.h"
#include   <lm.h>  
#include "ConnectThread.h"
#pragma   comment(lib, "NETAPI32.LIB ") 

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define LIMITCOUNT  1 //历史数据每次转10个 autorun
extern BOOL g_bConvertHisAll;
extern CDBServer theApp;
extern CtheDBServer theServer;
CString g_bakdate;
#define WM_ICON_NOTIFY  WM_USER+12
CDBServerDlg *g_pMainWnd=NULL;
#define IPC_CUSTOM_MSG2	_T("{D4F876E2-w78F-22D5-q98A-Y0B0D07B847C}")
UINT g_wmClose = RegisterWindowMessage(IPC_CUSTOM_MSG2);
BOOL g_bCheckAll=0;
BYTE *g_pSkinData=NULL;
DWORD  g_SkinLeng;
BOOL g_bAutoRun=0;
CStringArray g_filedatearray;
extern BOOL EncryptFile2(BYTE *buffer, DWORD leng, PCHAR szPassword);
extern CStringArray g_conniparray;

CArray<CDatabase*,CDatabase*>g_pHistoryDBarray[200];
CDatabase *g_pDB[200];
CConnectThread *g_pThreadPt[200];
int g_nDBCount=0;
/////////////////////////////////////////////////////////////////////////////
// CDBServerDlg dialog
#pragma comment(lib, "Shlwapi.lib")
extern DWORD g_nSendCode;
extern BOOL g_bReturned;
CString GetPathFromNetShareName(CString name)
{
	NET_API_STATUS   res;
	SHARE_INFO_502   *   psi   =   NULL;
	WCHAR   wszShareName[255];
	CString   sPathName;
	TCHAR   szPathName[255];
	TCHAR   path[255];
	memset(path, 0, 255);
	//转换成宽字符
 	MultiByteToWideChar(CP_ACP,   0,   name,   -1,   wszShareName,   255);
 	res   =   NetShareGetInfo(   NULL,(char   *)wszShareName,502,(LPBYTE   *)&psi);
	if(res   ==   NERR_Success)
	{
		wsprintf((char*)szPathName,   "%S ",   psi->shi502_path);
	 	sPathName   =   szPathName;
		sPathName.TrimRight ();
	}
	else
	{
		::WriteLogin ("转换路径失败");
	}
 
	//释放缓冲
	NetApiBufferFree(psi);
	return sPathName;
}

CString GetModifyTime2(CString path)
{
	try
	{
	CFileFind finder;
	BOOL bWorking = finder.FindFile(path); 
	if(bWorking)
	{ 
		finder.FindNextFile( ); 
		CTime tm;
		finder.GetLastWriteTime(tm);
		CString   stime; 
		stime.Format ("%d%02d%02d", tm.GetYear (),tm.GetMonth (),tm.GetDay ());
		return stime;
	}
	return "";
	}
	catch(...)
	{
		WriteLogin("出错");
	}



/*	HANDLE   hFile;
	WIN32_FIND_DATA   wfd;   
 	SYSTEMTIME   systime;   
	FILETIME   localtime;    
	CString   stime;     //输出时间   
	memset(&wfd,   0,   sizeof(wfd));   
	if((hFile=FindFirstFile(path,   &wfd))==INVALID_HANDLE_VALUE)   
		return "";
	//ok,转换时间
	FileTimeToLocalFileTime(&wfd.ftCreationTime,&localtime);
	FileTimeToSystemTime(&localtime,&systime);
	stime.Format("%4d%02d%02d",
           systime.wYear,systime.wMonth,systime.wDay); 
	return stime;*/
}
DWORD GetLastDirTime(CString dir)
{
	try
	{
	CString path=dir;
	path.TrimRight ("\\");
	path+="\\";
	path+="modifytime";
	CStdioFile fp;
	if(::PathFileExists (path))
	{
		fp.Open (path,CFile::modeRead);
		fp.ReadString (path);
		fp.Close ();
		path.TrimLeft ();path.TrimRight ();
		path.Replace ("-", "");
 
		return atoi(path);
	}
	else
	{
	using namespace helper_coffs;
	ffsco o;
	o.dirs(1);
	o.find(LPCSTR(dir), LPCSTR("*.jpg"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_file();
	CString path;
	DWORD maxdate=0;
	for (it = coo.begin();
	coo.end() != it;
	it ++) 
	{
		if(g_pMainWnd->m_bTerminate2)return 99999999;
		path=(*it).c_str();
		maxdate=max(maxdate, atol(GetModifyTime2(path)));
	}
	return maxdate;
	}
	}
	catch(...)
	{
		WriteLogin("出错");
	}
}

CString GetModifyTime(CString path)
{
	try
	{
	HANDLE   hFile;
	WIN32_FIND_DATA   wfd;   
//	SYSTEMTIME   systime;   
	FILETIME   localtime;    
	CString   stime;     //输出时间   
	memset(&wfd,   0,   sizeof(wfd));   
	if((hFile=FindFirstFile(path,   &wfd))==INVALID_HANDLE_VALUE)   
		return "";
	//ok,转换时间
	FileTimeToLocalFileTime(&wfd.ftLastWriteTime,&localtime);
	stime.Format ("%16d%16d", localtime.dwHighDateTime , localtime.dwLowDateTime);
/*	FileTimeToSystemTime(&localtime,&systime);
	stime.Format("%4d-%02d-%02d  %02d:%02d:%02d",
            systime.wYear,systime.wMonth,systime.wDay,systime.wHour,   
            systime.wMinute,systime.wSecond);*/
	return stime;
	}
	catch(...)
	{
		WriteLogin("出错");
	}
}

static UINT auIDStatusBar[] = 
{
	ID_SEPARATOR,
	ID_INDICATOR_DATA_RECEIVED,
	ID_INDICATOR_DATA_SEND,
	ID_INDICATOR_ONLINELED,
	ID_INDICATOR_OFFLINELED
};


/********************************************************************/
/*																	*/
/* Function name : CDBServerDlg::CDBServerDlg					*/
/* Description   : Constructor										*/
/*																	*/
/********************************************************************/
CDBServerDlg::CDBServerDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CDBServerDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDBServerDlg)
	//}}AFX_DATA_INIT
	m_hIcon = AfxGetApp()->LoadIcon(IDI_DBServer);
	m_bTerminate=false;
	m_bRunning=false;
	m_hThread = NULL;
	m_bTerminate2=false;
	m_bRunning2=false;
	m_hThread2 = NULL;
	hInst=NULL;
    CString version = _T ("Version 1.0");
	g_bAutoRun=AfxGetApp()->GetProfileInt (version, "brun", 0);


	for(int i=0; i<200; i++)
	{
		g_pDB[i]=NULL;
		g_pThreadPt[i]=NULL;
	}
}

/********************************************************************/
/*																	*/
/* Function name : CDBServerDlg::~CDBServerDlg				*/
/* Description   : Destructor										*/
/*																	*/
/********************************************************************/
CDBServerDlg::~CDBServerDlg()
{
	for(int i=0; i<200; i++)
	{
		CDatabase *db=g_pDB[i];
		if(db) 
		{
			db->Close ();
			delete db;
		}
		for(int j=0; j<g_pHistoryDBarray[i].GetSize (); j++)
		{
			CDatabase *db=g_pHistoryDBarray[i].ElementAt (j);
			if(db)
			{
				db->Close ();
				delete db;
			}
		}
		g_pHistoryDBarray[i].RemoveAll ();
	}
}


/********************************************************************/
/*																	*/
/* Function name : CDBServerDlg::DoDataExchange					*/		
/* Description   : Called by the framework to exchange and validate */
/*				   dialog data.										*/
/*																	*/
/********************************************************************/
void CDBServerDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDBServerDlg)
	DDX_Control(pDX, IDC_INFOBAR, m_InfobarCtrl);
	DDX_Control(pDX, IDC_OUTLOOKBAR, m_OutlookBar);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CDBServerDlg, CDialog)
	//{{AFX_MSG_MAP(CDBServerDlg)
	ON_WM_DESTROY()
	ON_COMMAND(ID_SERVER_START, OnServerStart)
	ON_UPDATE_COMMAND_UI(ID_SERVER_START, OnUpdateServerStart)
	ON_COMMAND(ID_SERVER_STOP, OnServerStop)
	ON_UPDATE_COMMAND_UI(ID_SERVER_STOP, OnUpdateServerStop)
	ON_COMMAND(ID_SERVER_EXIT, OnServerExit)
	ON_NOTIFY(NM_CLICK, IDC_OUTLOOKBAR, OnClickOutlookBar)
	ON_NOTIFY(LVN_KEYDOWN, IDC_OUTLOOKBAR, OnKeydownOutlookBar)
	ON_COMMAND(ID_USER_ACCOUNTS, OnUserAccounts)
	ON_WM_CLOSE()
	ON_COMMAND(IDC_VIEW_TRACE, OnViewTrace)
	ON_COMMAND(IDC_VIEW_ONLINE_USERS, OnViewOnlineUsers)
	ON_COMMAND(IDC_VIEW_CONFIGURATION, OnViewConfiguration)
	ON_UPDATE_COMMAND_UI(IDC_VIEW_TRACE, OnUpdateViewTrace)
	ON_UPDATE_COMMAND_UI(IDC_VIEW_ONLINE_USERS, OnUpdateViewOnlineUsers)
	ON_UPDATE_COMMAND_UI(IDC_VIEW_CONFIGURATION, OnUpdateViewConfiguration)
	ON_COMMAND(IDC_VIEW_STATISTICS, OnViewStatistics)
	ON_UPDATE_COMMAND_UI(IDC_VIEW_STATISTICS, OnUpdateViewStatistics)
	ON_COMMAND(IDC_VIEW_SECURITY, OnViewSecurity)
	ON_UPDATE_COMMAND_UI(IDC_VIEW_SECURITY, OnUpdateViewSecurity)
	ON_COMMAND(ID_ACCOUNT_WIZARD, OnAccountWizard)
	ON_WM_TIMER()
	ON_COMMAND(IDM_OPEN, OnOpen)
	ON_COMMAND(IDM_EXIT, OnExit)
	ON_COMMAND(IDM_AUTORUN, OnAutorun)
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_ICON_NOTIFY, OnTrayNotification)
	ON_REGISTERED_MESSAGE(g_wmClose, OnAbortClose)
END_MESSAGE_MAP()


LRESULT CDBServerDlg::OnAbortClose(WPARAM wParam, LPARAM lParam)
{
	if(wParam==1)
	{
//	OnButton2();
//	OnButton1();
	}
	else if(wParam==2)
	{
		WriteLogin("连接失败,服务将重启");
		OnExit2();
	}
	else if(wParam==3)//更新分店
	{
		LoadBranchInfo();
	}
	return 1;
}
CString g_localip;
void MyGetIPByName(CString &name)
{
	CString strIP=name;
	name.Empty ();
	DWORD dwServerIP=0;
	HOSTENT   *host   =   gethostbyname(strIP); 
	struct   in_addr   addr; 
	if   (host   !=   NULL) 
	{
		for(int i   =   0;   host-> h_addr_list[i]   !=   NULL;   i   ++) 
		{ 
			memset(&addr,   0,   sizeof(addr)); 
			memcpy(&addr.S_un.S_addr,   host-> h_addr_list[i],   host-> h_length); 
			dwServerIP   =   ntohl(addr.S_un.S_addr); 
		}
		BYTE*   pIP   =   (BYTE*)&dwServerIP; 
		name.Format(_T("%d.%d.%d.%d"),   pIP[3],   pIP[2],   pIP[1],   pIP[0]); 
	}
}
BOOL CDBServerDlg::OnInitDialog()
{
	g_pMainWnd=this;
	CDialog::OnInitDialog();
		char server[50];
	DWORD leng=50;
	::GetComputerName (server, &leng);	
	g_localip=server ;
	MyGetIPByName(g_localip);
	// setup listview ctrl, so that it looks like the outbar control
	SetupOutlookBar();

	// Add statusbar to the dialog
    CreateStatusbar();

	CRect rect;
	GetDlgItem(IDC_STATIC1)->GetWindowRect(rect);
	ScreenToClient(rect);
	rect.right+=4;
	GetDlgItem(IDC_STATIC1)->MoveWindow(rect);
 
 
	// create property pages
	m_TracePage.Create(IDD_PROPPAGE_TRACE, this);
	m_OnlineUsersPage.Create(IDD_PROPPAGE_ONLINE, this);
	m_ConfigurationPage.Create(IDD_PROPPAGE_CONFIGURATION, this);
	m_StatisticsPage.Create(IDD_PROPPAGE_STATISTICS, this);
	m_SecurityPage.Create(IDD_PROPPAGE_SECURITY, this);

	// activate main page 
	ActivatePage(0);

	// Set the icon for this dialog.
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	// get registry values
 
   
	
 


ENCODE_START
#ifndef _DEBUG
#ifdef TIMEDOG_VERSION
	try
	{
 
	CheckRegCode();
 

	DWORD id;
	TCHAR HKey[20]="ffffffff",LKey[20]="ffffffff";
	TCHAR OutTime[50];
	TCHAR DevicePath[ 260];
	if(FindPort(0,DevicePath)!=0)
		exit(1);
	 
//LIBC.LIB,libcp.lib,msvcprt.lib
	TCHAR  year[10],month[10],day[10],hour[10],minute[10],second[10];
 	ReadTimeAuthFromEprom(HKey,LKey, OutTime, &id, 30128, HKey, LKey, DevicePath);
 	CString str=OutTime;
	CString temp="年";
	int pos=str.Find (temp);
	temp=str.Left (pos);
	str=str.Right (str.GetLength ()-pos-2);
	strcpy(year, temp.GetBuffer (0));temp.ReleaseBuffer ();

	temp="月";
	pos=str.Find (temp);
	temp=str.Left (pos);
	str=str.Right (str.GetLength ()-pos-2);
	strcpy(month, temp.GetBuffer (0));temp.ReleaseBuffer ();

	temp="日";
	pos=str.Find (temp);
	temp=str.Left (pos);
	str=str.Right (str.GetLength ()-pos-2);
	strcpy(day, temp.GetBuffer (0));temp.ReleaseBuffer ();

	temp="小时";
	pos=str.Find (temp);
	temp=str.Left (pos);
	str=str.Right (str.GetLength ()-pos-4);
	strcpy(hour, temp.GetBuffer (0));temp.ReleaseBuffer ();

	temp="分钟";
	pos=str.Find (temp);
	temp=str.Left (pos);
	str=str.Right (str.GetLength ()-pos-4);
	strcpy(minute, temp.GetBuffer (0));temp.ReleaseBuffer ();
	temp="0";
 	strcpy(second, temp.GetBuffer (0));temp.ReleaseBuffer ();
	long time1=ConvertStringToTimerReal(year, month, day, hour, minute, second);
 

	GetRunTimer(year, month, day, hour, minute, second, DevicePath);
	long time2=ConvertStringToTimerReal(year, month, day, hour, minute, second);
    
	if( (time1-time2) <0)
	{
		AfxMessageBox("加密锁已过期, 请与经销商联系!!!");
		InputAuthDlg authdlg;
		authdlg.m_id=id;
		authdlg.m_time1=time1;
		authdlg.m_time2=time2;
		if(authdlg.DoModal ()!=IDOK)
		{
			CDialog::OnCancel ();
			return false;
		}
	}
	else if((time1-time2) <360000)//10天=10*10*3600=360000 能用天数小于10天.
	{
		DogTimeOutDlg dlg;
		dlg.hour=(time1-time2)/3600;
		if(dlg.DoModal ()==IDOK)
		{
			InputAuthDlg authdlg;
			authdlg.m_id=id;
			authdlg.m_time1=time1;
			authdlg.m_time2=time2;
			authdlg.DoModal ();
		}
	}	 
	BOOL bOK=1;
	long d[8];double f[8];
	char s0[50]="",s1[50]="",s2[50]="",s3[50]="",s4[50]="",s5[50]="",s6[50]="",s7[50]="";
	//运行自定义函数
	SoftKey ytSoftKey;
	int ret=ytSoftKey.Ini();
	ret=ytSoftKey.checktime(&d[0],&d[1],&d[2],&d[3],&d[4],&d[5],&d[6],&d[7],
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		bOK=0;
 
	}	 
////////////////////////写申请码
	if(bOK)
	{
	str=GetRegCode(id, time1, time2);
	char path[MAX_PATH];
	::GetSystemDirectory (path, MAX_PATH);
	CString sysdir=path;
	sysdir+="\\regcode.txt";
	CStdioFile fp;
	if(fp.Open (sysdir, CFile::modeWrite|CFile::modeCreate))
	{
		fp.WriteString (str);
		fp.Close ();
	} 
	}
/////////////////////////
	}
	catch(...)
	{
	}
#endif
 #endif
		g_curdb=&g_db;
ENCODE_END


 
	OnButton1();
	GetFileDate(); 
	LoadDB();

	int aaaa=30;
	while(aaaa--)AddOneConn();
 


   SetTimer(2, 10, NULL);
	SetTimer (1, 2*60*1000, NULL);
    SetTimer (4, 1000*60*2, NULL);
	SetTimer (7, 1000*60*60*1, NULL); 
 	SetTimer (8, 3000, NULL);


	CheckBakState();
   hInst   =   LoadLibrary( "SENSAPI.DLL");   //加载动态库 
   if(hInst)
   {
	   typedef   BOOL   (WINAPI   *MYFUNC)(LPDWORD);   
	   MYFUNC   IsNetworkConnect   =   NULL; 
	   //取得IsNetworkAlive函数指针   
	   IsNetworkConnect=(MYFUNC)GetProcAddress(hInst,   "IsNetworkAlive"); 
        if(IsNetworkConnect) 
        {
			DWORD   dwActiveWan=1; 
			if(IsNetworkConnect(&dwActiveWan))
				m_bNetWorkOK=1;
			else
				m_bNetWorkOK=0;
			SetTimer(5, 10000, NULL);
		}
		else
			m_bNetWorkOK=0;
   }
   else
	   m_bNetWorkOK=0; 
 
	return TRUE;
}

/********************************************************************/
/*																	*/
/* Function name : OnDestroy										*/		
/* Description   : Handle WM_DESTROY message						*/
/*																	*/
/********************************************************************/
void CDBServerDlg::OnDestroy() 
{
	OnServerStop();
	KillTimer(1);
	KillTimer(2);
	KillTimer(3);
	KillTimer(4);
	KillTimer(5);
	KillTimer(6);
	KillTimer(7);
	KillTimer(8);
 
	CDialog::OnDestroy();
}

/********************************************************************/
/*																	*/
/* Function name : OnServerStart									*/		
/* Description   : Start Date Server -> start listening on port 21	*/
/*																	*/
/********************************************************************/
//启动数据服务器，使其在21号端口侦听
void CDBServerDlg::OnServerStart() 
{
	ServerStart();
}

BOOL CDBServerDlg::ServerStart() 
{
 

	if (theServer.Start())
	{
		
		m_wndStatusBar.SetPaneText(0, "数据服务已启动", TRUE);
		SetOnlineLed(TRUE);
		SetOfflineLed(FALSE);	WriteLogin("启动成功");
		return 1;
	}
	else
	{
			WriteLogin("启动失败");
		CDialog::OnCancel ();
		return 0;
	}
}
/********************************************************************/
/*																	*/
/* Function name : OnUpdateServerStart								*/		
/* Description   : Update 'Start' status							*/
/*																	*/
/********************************************************************/
void CDBServerDlg::OnUpdateServerStart(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!theServer.IsActive());	
}


/********************************************************************/
/*																	*/
/* Function name : OnServerStop										*/		
/* Description   : Stop Date Server									*/
/*																	*/
/********************************************************************/
//停止服务器
void CDBServerDlg::OnServerStop() 
{
	theServer.Stop();
	m_wndStatusBar.SetPaneText(0, "数据服务已停止", TRUE);
	SetOnlineLed(FALSE);
	SetOfflineLed(TRUE);
}


/********************************************************************/
/*																	*/
/* Function name : OnUpdateServerStop								*/		
/* Description   : Update 'Stop' status								*/
/*																	*/
/********************************************************************/
void CDBServerDlg::OnUpdateServerStop(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(theServer.IsActive());
}

/********************************************************************/
/*																	*/
/* Function name : OnServerExit										*/		
/* Description   : Let's get out of here...							*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnServerExit() 
{
	OnCancel();	
}


/********************************************************************/
/*																	*/
/* Function name : CDBServerDlg::SetupOutlookBar					*/
/* Description   : Initialize listview, change color/iconspacing to	*/
/*				   make it look a little bit like the outlook bar.	*/
/*																	*/
/********************************************************************/
void CDBServerDlg::SetupOutlookBar()
{
    // create Imagelist
	m_ImageList.Create(32, 32, ILC_COLOR16|ILC_MASK,1, 4);

    HICON hIcon = ::LoadIcon (AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_LOG));
    m_ImageList.Add(hIcon);
    hIcon = ::LoadIcon (AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ONLINE_USERS));
    m_ImageList.Add(hIcon);
    hIcon = ::LoadIcon (AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_CONFIGURATION));
    m_ImageList.Add(hIcon);
    hIcon = ::LoadIcon (AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_SECURITY));
    m_ImageList.Add(hIcon);
    hIcon = ::LoadIcon (AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_STATISTICS));
    m_ImageList.Add(hIcon);


	
	m_OutlookBar.SetImageList(&m_ImageList, LVSIL_NORMAL);

	CRect rc;
	m_OutlookBar.GetClientRect(rc);
	
	// set new icon spacing
	m_OutlookBar.SetIconSpacing(rc.Width(), 64);

	// change colors
	m_OutlookBar.SetTextColor(RGB(255,255,255));
	m_OutlookBar.SetTextBkColor(RGB(128,128,128));
	m_OutlookBar.SetBkColor(RGB(128,128,128));	

	// insert items
	m_OutlookBar.InsertColumn(0, "OutlookBar");

	m_OutlookBar.InsertItem(0, "服务器日志", 0);
	m_OutlookBar.InsertItem(1, "在线用户", 1);
	m_OutlookBar.InsertItem(2, "关于", 2);
	m_OutlookBar.InsertItem(3, "功能区", 3);
/*	m_OutlookBar.InsertItem(4, "Security", 4);*/

//	m_OutlookBar.SetExtendedStyle(LVS_EX_TRACKSELECT);
}


/********************************************************************/
/*																	*/
/* Function name : CDBServerDlg::MoveChilds						*/		
/* Description   : Move child windows into place holder area.		*/
/*																	*/
/********************************************************************/
void CDBServerDlg::MoveChilds()
{
	// position property pages 
	CRect rcDlgs;
	
	// get dialog area rect
	GetDlgItem(IDC_DIALOG_AREA)->GetWindowRect(rcDlgs);
	
	ScreenToClient(rcDlgs);
	
	m_ConfigurationPage.MoveWindow(rcDlgs); 
	m_TracePage.MoveWindow(rcDlgs); 
	m_OnlineUsersPage.MoveWindow(rcDlgs); 
	m_StatisticsPage.MoveWindow(rcDlgs); 
	m_SecurityPage.MoveWindow(rcDlgs); 
}


/********************************************************************/
/*																	*/
/* Function name : CDBServerDlg::ActivatePage					*/
/* Description   : Called when an icon on the outlookbar is pressed.*/
/*																	*/
/********************************************************************/
void CDBServerDlg::ActivatePage(int nIndex)
{ 
	switch(nIndex)
	{
		case 0:
			m_OnlineUsersPage.ShowWindow(SW_HIDE);	
			m_ConfigurationPage.ShowWindow(SW_HIDE);
			m_StatisticsPage.ShowWindow(SW_HIDE);	
			m_SecurityPage.ShowWindow(SW_HIDE);	
			m_TracePage.ShowWindow(SW_SHOW);
			m_InfobarCtrl.SetText("服务器日志");
			break;
		case 1:
			m_TracePage.ShowWindow(SW_HIDE);	
			m_ConfigurationPage.ShowWindow(SW_HIDE);	
			m_StatisticsPage.ShowWindow(SW_HIDE);	
			m_SecurityPage.ShowWindow(SW_HIDE);	
			m_OnlineUsersPage.RefreshData();
			m_OnlineUsersPage.ShowWindow(SW_SHOW);
			m_InfobarCtrl.SetText("在线用户");
			break;
		case 2:
			m_OnlineUsersPage.ShowWindow(SW_HIDE);	
			m_TracePage.ShowWindow(SW_HIDE);	
			m_StatisticsPage.ShowWindow(SW_HIDE);	
			m_SecurityPage.ShowWindow(SW_HIDE);	
			m_ConfigurationPage.ShowWindow(SW_SHOW);	
			m_InfobarCtrl.SetText("关于");
			break;
		case 4:
			m_OnlineUsersPage.ShowWindow(SW_HIDE);	
			m_TracePage.ShowWindow(SW_HIDE);	
			m_ConfigurationPage.ShowWindow(SW_HIDE);	
			m_SecurityPage.ShowWindow(SW_HIDE);	
			m_StatisticsPage.ShowWindow(SW_SHOW);	
			m_InfobarCtrl.SetText("Statistics");
			break;
		case 3:
			m_OnlineUsersPage.ShowWindow(SW_HIDE);	
			m_TracePage.ShowWindow(SW_HIDE);	
			m_ConfigurationPage.ShowWindow(SW_HIDE);	
			m_SecurityPage.ShowWindow(SW_SHOW);	
			m_StatisticsPage.ShowWindow(SW_HIDE);	
			m_InfobarCtrl.SetText("功能区");
			break;
		default:
			break;
	}
	MoveChilds();
}


/********************************************************************/
/*																	*/
/* Function name : CDBServerDlg::OnClickOutlookBar				*/
/* Description   : User clicked on our listview -> activate page.	*/
/*																	*/
/********************************************************************/
void CDBServerDlg::OnClickOutlookBar(NMHDR* pNMHDR, LRESULT* pResult) 
{
	// get index of selected item
	int nIndex = m_OutlookBar.GetNextItem(-1, LVNI_ALL | LVNI_SELECTED); 
    
    if(nIndex == -1)
        return;
		
	ActivatePage(nIndex);

	*pResult = 0;
}


/********************************************************************/
/*																	*/
/* Function name : CDBServerDlg::OnKeydownOutlookBar				*/
/* Description   : User pressed a key -> activate page.				*/
/*																	*/
/********************************************************************/
void CDBServerDlg::OnKeydownOutlookBar(NMHDR* pNMHDR, LRESULT* pResult) 
{
	LV_KEYDOWN* pLVKeyDow = (LV_KEYDOWN*)pNMHDR;

    // get index of selected item
	int nIndex = m_OutlookBar.GetNextItem(-1, LVNI_ALL | LVNI_SELECTED); 
    
    if(nIndex == -1)
        return;

	if (pLVKeyDow->wVKey == VK_DOWN)
	{
		if (m_OutlookBar.GetItemCount()-1 > nIndex)
		{
			ActivatePage(nIndex+1);
		}
	}
	else
	if (pLVKeyDow->wVKey == VK_UP)
	{
		if (nIndex > 0)
		{
			ActivatePage(nIndex-1);
		}
	}
	else
	if (pLVKeyDow->wVKey == VK_NEXT)
	{
		ActivatePage(m_OutlookBar.GetItemCount()-1);
	}
	else
	if (pLVKeyDow->wVKey == VK_PRIOR)
	{
		ActivatePage(0);
	}

	*pResult = 0;
}



/********************************************************************/
/*																	*/
/* Function name : CreateStatusbar									*/	
/* Description   : This function creates a statusbar on a dialogbox.*/
/*																	*/
/********************************************************************/
BOOL CDBServerDlg::CreateStatusbar()
{
	// Create the Toolbar and attach the resource
	if(!m_wndToolBar.Create(this) || !m_wndToolBar.LoadToolBar(IDR_TOOLBAR1))
	{
		TRACE0("Failed to Create Dialog Toolbar\n");
		return FALSE;	
	}

	m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() | CBRS_SIZE_DYNAMIC | CBRS_TOOLTIPS | CBRS_FLYBY);
	
	// Make it flat.
	m_wndToolBar.ModifyStyle(0, m_wndToolBar.GetStyle()|TBSTYLE_FLAT);

	// Create status bar at the bottom of the dialog window
	if (m_wndStatusBar.Create(this))
	{
		m_wndStatusBar.SetIndicators(auIDStatusBar, sizeof(auIDStatusBar)/sizeof(UINT));
		
		m_wndStatusBar.SetPaneText(0, "Date Server is offline", TRUE);
		// Make a sunken or recessed border around the first pane
		m_wndStatusBar.SetPaneInfo(0, m_wndStatusBar.GetItemID(0), SBPS_STRETCH, NULL );

		SetOnlineLed(FALSE);
		SetOfflineLed(FALSE);

		m_wndStatusBar.SetPaneInfo(m_wndStatusBar.CommandToIndex(ID_INDICATOR_ONLINELED),ID_INDICATOR_ONLINELED, SBPS_NOBORDERS, 14);
//		m_wndStatusBar.GetStatusBarCtrl().SetTipText(m_wndStatusBar.CommandToIndex(ID_INDICATOR_ONLINELED), "This status light is green when the server is online");

		m_wndStatusBar.SetPaneInfo(m_wndStatusBar.CommandToIndex(ID_INDICATOR_OFFLINELED),ID_INDICATOR_OFFLINELED, SBPS_NOBORDERS, 14);
//		m_wndStatusBar.GetStatusBarCtrl().SetTipText(m_wndStatusBar.CommandToIndex(ID_INDICATOR_OFFLINELED), "This status light is green when the server is online");
	}

    // We need to resize the dialog to make room for control bars.
	// First, figure out how big the control bars are.
	CRect rcClientStart;
	CRect rcClientNow;
	GetClientRect(rcClientStart);
	RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0, reposQuery, rcClientNow);

    // Now move all the controls so they are in the same relative
	// position within the remaining client area as they would be
	// with no control bars.
	CPoint ptOffset(rcClientNow.left - rcClientStart.left, rcClientNow.top - rcClientStart.top); 

	CRect  rcChild;					
	CWnd* pwndChild = GetWindow(GW_CHILD);
	while (pwndChild)
	{                               
		pwndChild->GetWindowRect(rcChild);
		ScreenToClient(rcChild);
		rcChild.OffsetRect(ptOffset);
		pwndChild->MoveWindow(rcChild, FALSE);
		pwndChild = pwndChild->GetNextWindow();
	}

	// Adjust the dialog window dimensions
	CRect rcWindow;
	GetWindowRect(rcWindow);
	rcWindow.right += rcClientStart.Width() - rcClientNow.Width();
	rcWindow.bottom += rcClientStart.Height() - rcClientNow.Height();
	MoveWindow(rcWindow, FALSE);
	
	// And position the control bars
	RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0);
    return TRUE;
}


/********************************************************************/
/*																	*/
/* Function name : OnUserAccounts									*/		
/* Description   : Show user accounts.								*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnUserAccounts() 
{
	CUserAccountsDlg dlg;
	theServer.m_UserManager.GetUserList(dlg.m_UserArray);
	if (dlg.DoModal() == IDOK)
	{
		theServer.m_UserManager.UpdateUserList(dlg.m_UserArray);
	}
}


/********************************************************************/
/*																	*/
/* Function name : OnFTPUserConnected								*/
/* Description   : A user has connected to our server.				*/
/*																	*/
/********************************************************************/
void CDBServerDlg::OnFTPUserConnected(DWORD nThreadID, LPCTSTR lpszUser, LPCSTR lpszAddress)
{
	m_OnlineUsersPage.AddUser(nThreadID, lpszUser, lpszAddress);
}


/********************************************************************/
/*																	*/
/* Function name : OnFTPUserDisconnected							*/
/* Description   : A user has disconnected from our server.			*/
/*																	*/
/********************************************************************/
void CDBServerDlg::OnFTPUserDisconnected(DWORD nThreadID, LPCTSTR lpszUser)
{
	m_OnlineUsersPage.RemoveUser(nThreadID);
}


/********************************************************************/
/*																	*/
/* Function name : OnFTPStatusChange								*/		
/* Description   : FTP Status changed.								*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnFTPStatusChange(int nType, LPCTSTR lpszText)
{
	m_TracePage.AddTraceLine(nType, lpszText);
	
	switch(nType)
	{
		case 3:
			theApp.m_LogFile << error_lvl << date << time << lpszText << endl;
			break;
		default:
			theApp.m_LogFile << trace_lvl << date << time << lpszText << endl;
			break;
	}
}


/********************************************************************/
/*																	*/
/* Function name : OnFTPReceivedBytesChange							*/		
/* Description   : Number of received bytes has changed.			*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnFTPReceivedBytesChange(int nBytes) 
{
	m_StatisticsPage.SetValue(6, FormatSize(nBytes, 0));

	CString strStatus;
	strStatus.Format("%s received", FormatSize(nBytes, 0));
	m_wndStatusBar.SetPaneText(m_wndStatusBar.CommandToIndex(ID_INDICATOR_DATA_RECEIVED), strStatus, TRUE);

	CClientDC dc(this);
	CSize size = dc.GetTextExtent(strStatus);
	m_wndStatusBar.SetPaneInfo(m_wndStatusBar.CommandToIndex(ID_INDICATOR_DATA_RECEIVED), ID_INDICATOR_DATA_RECEIVED, SBPS_NORMAL, size.cx);
}


/********************************************************************/
/*																	*/
/* Function name : OnFTPSentBytesChange								*/		
/* Description   : Number of sent bytes has changed.				*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnFTPSentBytesChange(int nBytes)
{
	m_StatisticsPage.SetValue(7, FormatSize(nBytes, 0));

	CString strStatus;
	strStatus.Format("%s sent",  FormatSize(nBytes, 0));
	m_wndStatusBar.SetPaneText(m_wndStatusBar.CommandToIndex(ID_INDICATOR_DATA_SEND), strStatus, TRUE);
	CClientDC dc(this);
	CSize size = dc.GetTextExtent(strStatus);
	m_wndStatusBar.SetPaneInfo(m_wndStatusBar.CommandToIndex(ID_INDICATOR_DATA_SEND), ID_INDICATOR_DATA_SEND, SBPS_NORMAL, size.cx);
}


/********************************************************************/
/*																	*/
/* Function name : OnViewTrace										*/		
/* Description   : Handle menu selection.							*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnViewTrace() 
{
	ActivatePage(0);
}


/********************************************************************/
/*																	*/
/* Function name : OnViewOnlineUsers								*/		
/* Description   : Handle menu selection.							*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnViewOnlineUsers() 
{
	ActivatePage(1);
}


/********************************************************************/
/*																	*/
/* Function name : OnViewConfiguration								*/		
/* Description   : Handle menu selection.							*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnViewConfiguration() 
{
	ActivatePage(2);
}


/********************************************************************/
/*																	*/
/* Function name : OnViewStatistics									*/		
/* Description   : Handle menu selection.							*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnViewStatistics() 
{
	ActivatePage(3);
}


/********************************************************************/
/*																	*/
/* Function name : OnViewSecurity									*/		
/* Description   : Handle menu selection.							*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnViewSecurity() 
{
	ActivatePage(4);
}


/********************************************************************/
/*																	*/
/* Function name : OnUpdateViewTrace								*/		
/* Description   : Update menu state of Trace item.					*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnUpdateViewTrace(CCmdUI* pCmdUI) 
{
	pCmdUI->SetRadio(m_TracePage.IsWindowVisible());	
}


/********************************************************************/
/*																	*/
/* Function name : OnUpdateViewOnlineUsers							*/		
/* Description   : Update menu state of Online Users item.			*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnUpdateViewOnlineUsers(CCmdUI* pCmdUI) 
{
	pCmdUI->SetRadio(m_OnlineUsersPage.IsWindowVisible());		
}


/********************************************************************/
/*																	*/
/* Function name : OnUpdateViewConfiguration						*/		
/* Description   : Update menu state of Configuration item.			*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnUpdateViewConfiguration(CCmdUI* pCmdUI) 
{
	pCmdUI->SetRadio(m_ConfigurationPage.IsWindowVisible());			
}


/********************************************************************/
/*																	*/
/* Function name : OnUpdateViewStatistics							*/		
/* Description   : Update menu state of Statistics item.			*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnUpdateViewStatistics(CCmdUI* pCmdUI) 
{
	pCmdUI->SetRadio(m_StatisticsPage.IsWindowVisible());				
}


/********************************************************************/
/*																	*/
/* Function name : OnUpdateViewSecurity								*/		
/* Description   : Update menu state of Security item.				*/	
/*																	*/
/********************************************************************/
void CDBServerDlg::OnUpdateViewSecurity(CCmdUI* pCmdUI) 
{
	pCmdUI->SetRadio(m_SecurityPage.IsWindowVisible());					
}

/********************************************************************/
/*																	*/
/* Function name : SetOnlineLed										*/	
/* Description   : Turn online LED on/off.							*/
/*																	*/
/********************************************************************/
void CDBServerDlg::SetOnlineLed(BOOL bOnline)
{
	HICON hIcon = (HICON)::LoadImage(AfxGetInstanceHandle(),
				bOnline ? MAKEINTRESOURCE(IDI_LED_GREEN) : MAKEINTRESOURCE(IDI_LED_OFF),
				 IMAGE_ICON, 16, 16, LR_SHARED);
	m_wndStatusBar.GetStatusBarCtrl().SetIcon(m_wndStatusBar.CommandToIndex(ID_INDICATOR_ONLINELED), hIcon);
	m_wndStatusBar.GetStatusBarCtrl().Invalidate();
	m_wndStatusBar.GetStatusBarCtrl().UpdateWindow();
	DestroyIcon(hIcon);
}


/********************************************************************/
/*																	*/
/* Function name : SetOfflineLed									*/	
/* Description   : Turn offline LED on/off.							*/
/*																	*/
/********************************************************************/
void CDBServerDlg::SetOfflineLed(BOOL bOffline)
{
	HICON hIcon = (HICON)::LoadImage(AfxGetInstanceHandle(),
				bOffline ? MAKEINTRESOURCE(IDI_LED_RED) : MAKEINTRESOURCE(IDI_LED_OFF),
				 IMAGE_ICON, 16, 16, LR_SHARED);
	m_wndStatusBar.GetStatusBarCtrl().SetIcon(m_wndStatusBar.CommandToIndex(ID_INDICATOR_OFFLINELED), hIcon);
	m_wndStatusBar.GetStatusBarCtrl().Invalidate();
	m_wndStatusBar.GetStatusBarCtrl().UpdateWindow();
	DestroyIcon(hIcon);
}

void CDBServerDlg::OnFTPStatisticChange(int nType, int nValue)
{
	m_StatisticsPage.SetValue(nType, nValue);
}
/********************************************************************/
/*																	*/
/* Function name : FormatSize										*/
/* Description   : Format size, the way explorer diplays it			*/
/*																	*/
/********************************************************************/
char* CDBServerDlg::FormatSize(DWORD dwSizeLow, DWORD dwSizeHigh)
{
	static char szBuff[100];

	unsigned __int64 nFileSize = ((unsigned __int64)(((DWORD)(dwSizeLow)) | 
								 ((unsigned __int64)((DWORD)(dwSizeHigh))) << 32));
	unsigned __int64 kb = 0;

	if (nFileSize > 1024)
	{
		kb = nFileSize / 1024;
		if (nFileSize % 1024)
			kb++;
	}

	// make it a string
	_ui64tot(kb, szBuff, 10);

	// add thousand seperators
	int nLength = lstrlen(szBuff);
	if (nLength > 3)
	{
		LPCTSTR ptr = szBuff;
		ptr += (nLength-1);

		char szTemp[100];

		LPTSTR ptrTemp = szTemp;
		for(int i=0; i<nLength; i++)
		{
			if (i && ((i % 3) == 0)) 
			{
				if (*ptrTemp != ',')
				{
					*ptrTemp = ',';
					ptrTemp = _tcsinc(ptrTemp);
				}
			}
			*ptrTemp = *ptr;
			ptrTemp = _tcsinc(ptrTemp);
			ptr = _tcsdec(szBuff, ptr);
		}
		// terminate string
		*ptrTemp = '\0';
		// reverse string
		_tcsrev(szTemp);
		lstrcpy(szBuff, szTemp);
	}
	// add 'KB' to it
	lstrcat(szBuff, " KB");
	return szBuff;
}


/********************************************************************/
/*																	*/
/* Function name : OnAccountWizard									*/
/* Description   : Launch New Account Wizard						*/
/*																	*/
/********************************************************************/
void CDBServerDlg::OnAccountWizard() 
{
	CBitmap bmpHeader, bmpWatermark;

	VERIFY(bmpHeader.LoadBitmap(IDB_BANNER));
	VERIFY(bmpWatermark.LoadBitmap(IDB_WATERMARK));
	
	// show windows 2000-like wizard
	CWizardSheet wizSheet("New Account Wizard", this, 0, bmpWatermark, NULL, bmpHeader);
	wizSheet.m_psh.hInstance = ::GetModuleHandle(NULL);
	if (wizSheet.DoModal() == ID_WIZFINISH)
	{
		CArray<CUser, CUser&> m_UserArray;

		theServer.m_UserManager.GetUserList(m_UserArray);
		
		int nIndex = -1;
		for (int i=0; i<m_UserArray.GetSize(); i++)
		{
			// if it already exists -> update it
			if (m_UserArray[i].m_strName.CompareNoCase(wizSheet.m_Page1.m_strAccountName) == 0)
			{
				nIndex = i;
				break;
			}
		}

		// add new account ?
		if (nIndex == -1)
		{
			CUser user;
			nIndex = m_UserArray.Add(user);		
		}
		m_UserArray[nIndex].m_bAccountDisabled = FALSE;
		m_UserArray[nIndex].m_strName = wizSheet.m_Page1.m_strAccountName;
		m_UserArray[nIndex].m_strPassword = wizSheet.m_Page2.m_strPassword;
		
		// add home directory
		CDirectory directory;
		
		directory.m_strDir = wizSheet.m_Page3.m_strHomeDirectory;
		directory.m_strAlias = "";
		directory.m_bIsHomeDir = TRUE;
		directory.m_bAllowCreateDirectory = wizSheet.m_Page4.m_bAllowCreateDirectory;
		directory.m_bAllowDelete = wizSheet.m_Page4.m_bAllowDelete;
		directory.m_bAllowDownload = wizSheet.m_Page4.m_bAllowDownload;
		directory.m_bAllowRename = wizSheet.m_Page4.m_bAllowRename;
		directory.m_bAllowUpload = wizSheet.m_Page4.m_bAllowUpload;
		directory.m_strAlias = "";

		m_UserArray[nIndex].m_DirectoryArray.Add(directory);
				
		// update 
		theServer.m_UserManager.UpdateUserList(m_UserArray);
	}	
}



void CDBServerDlg::OnCancel() 
{
	// TODO: Add extra cleanup here
	 
}

void CDBServerDlg::OnOK() 
{
	// TODO: Add extra validation here
	 
}

void CDBServerDlg::OnButton1() 
{
	// TODO: Add your control notification handler code here
	try
	{
 	theServer.Initialize(this);
	if(ServerStart()==0)return;
	if(g_pSkinData==NULL)InitLia();
 

/////////////////////
	CString	logdays;
	MyLock lock("dbaccessxiao");
 	CRecordset myset(&g_db);
	CString	sql="select logdays from version";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("logdays", logdays);
	myset.Close();


	int days=180;
	if(logdays=="1个月")
		days=31;
	else if(logdays=="2个月")
		days=61;
	else if(logdays=="3个月")
		days=92;
	else
		days=183;
	CTime tm=CTime::GetCurrentTime ();
	CTimeSpan dt(days, 0, 0, 0);
	tm-=dt;
	CString date=tm.Format ("%Y-%m-%d");
	sql="delete from [log] where [date]<'"+date+"'";
	g_db.ExecuteSQL (sql);
///////////////////
	tm=CTime::GetCurrentTime ();
	CTimeSpan dt2(183, 0, 0, 0);
	tm-=dt2;
	date=tm.Format ("%Y%m%d%H%M%S");
	sql="delete from sendreg where [status]='OK' and [timestamp]<'"+date+"'";
	g_db.ExecuteSQL (sql);
//////////////////////////////////

	sql="select version from version";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("version", sql);
	myset.Close();
	m_ConfigurationPage.m_versionno ="00"+sql;
	m_ConfigurationPage.UpdateData (0);
/////////////////////
	}
	catch(...)
	{
		WriteLogin("出错1");
	}
}

void CDBServerDlg::OnClose() 
{
	// TODO: Add your message handler code here and/or call default
	m_TrayIcon.Create(this,WM_ICON_NOTIFY,"影楼管理系统服务器" ,m_hIcon,IDR_MENUtray); //构造
 	ShowWindow(SW_HIDE); //隐藏窗口
}

LRESULT CDBServerDlg::OnTrayNotification(WPARAM wParam,LPARAM lParam)
{
	return m_TrayIcon.OnTrayNotification(wParam,lParam);
}

void CDBServerDlg::OnOpen() 
{
	// TODO: Add your command handler code here
	ShowWindow(SW_SHOW);
 
}

DWORD FindAppProcessID(CString path)
{
	try
	{
	HANDLE handle=::CreateToolhelp32Snapshot(TH32CS_SNAPALL,0);
	PROCESSENTRY32 Info;
	Info.dwSize = sizeof(PROCESSENTRY32);
	path.MakeLower ();
	if(::Process32First(handle,&Info))
	{
		do
		{
			CString ss=Info.szExeFile;
			ss.MakeLower ();
			if(ss==path)
			{
				::CloseHandle(handle);
				return Info.th32ProcessID;
			}
		}
		while(::Process32Next(handle,&Info));	
		::CloseHandle(handle);
	}
	return -1;
	}
	catch(...)
	{
	}
}


void CDBServerDlg::OnExit2()
{
	try
	{
	// TODO: Add your command handler code here
	TerminateThread();
	TerminateThread2();
 
	m_TrayIcon.RemoveIcon();
    if(g_pSkinData)delete []g_pSkinData;g_pSkinData=NULL;
	g_db.Close ();
	for(int i=0;i<dbarray.GetSize (); i++)
	{
		dbarray.ElementAt (i)->Close ();
		delete dbarray.ElementAt (i);
	}
	ReleaseBranchDB();
	}
	catch(...)
	{
		WriteLogin("出错在函数OnExit2中");
	}
	CDialog::OnCancel ();
}

void CDBServerDlg::OnExit() 
{
	try
	{
	// TODO: Add your command handler code here
	TerminateThread();
	TerminateThread2();
 
	DWORD id=FindAppProcessID("AutoRun.exe");
	if(id!=-1)
	{
		HANDLE ProcessHandle=OpenProcess(PROCESS_ALL_ACCESS,FALSE,id);
		if(ProcessHandle)TerminateProcess(ProcessHandle,0);
	}

	m_TrayIcon.RemoveIcon();
    if(g_pSkinData)delete []g_pSkinData;g_pSkinData=NULL;
	g_db.Close ();
	for(int i=0;i<dbarray.GetSize (); i++)
	{
		dbarray.ElementAt (i)->Close ();
		delete dbarray.ElementAt (i);
	}
	ReleaseBranchDB();
	}
	catch(...)
	{
		WriteLogin("出错在函数OnExit中");
	}
	CDialog::OnCancel ();
}

void CDBServerDlg::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	try
	{
	if(nIDEvent==1)
	{
		KillTimer(nIDEvent); 
		LoadThumbImages();
	}
	else if(nIDEvent==2)
	{
	KillTimer(nIDEvent);
	OnClose();

	try
	{
  	CheckHistoryData();
 	LoadBranchInfo2();
	}
	catch(...)
	{
	}
	}
	else if(nIDEvent==3)
	{
	 
	}
	else if(nIDEvent==4)
	{
		UpdateDate();
		CheckMemberMsg();
	 	BakPhoto();
	}
	else if(nIDEvent==5)
	{
	   typedef   BOOL   (WINAPI   *MYFUNC)(LPDWORD);   
	   MYFUNC   IsNetworkConnect   =   NULL; 
	   //取得IsNetworkAlive函数指针   
	   IsNetworkConnect=(MYFUNC)GetProcAddress(hInst,   "IsNetworkAlive"); 
        if(IsNetworkConnect) 
        {
			DWORD   dwActiveWan=1; 
			BOOL state;
			if(IsNetworkConnect(&dwActiveWan))
				state=1;
			else
				state=0;
			if(m_bNetWorkOK!=state)
			{
				KillTimer(nIDEvent);
				WriteLogin("网络断开");
				OnExit2();
			}
		}
	}
	else if(nIDEvent==6)
	{
	    KillTimer(nIDEvent);
		ShutDown();
	}
	else if(nIDEvent==7)
	{
		CheckBakState();
		GenUPhoneData();
	}
 	else if(nIDEvent==8)
	{
		CheckConnCount();
	}


	}
	catch(...)
	{
		WriteLogin("出错在函数Timer中");
	}
}


void LoadImageFromBuf(Image **img, BYTE *pData, DWORD leng)
{
	try
	{
	if(pData==NULL)return;
	if(*img)delete *img;
	*img=NULL;
		// Allocate global memory on which to create stream
	HGLOBAL m_hMem = GlobalAlloc(GMEM_MOVEABLE, leng);
	if(m_hMem==NULL)return;
	BYTE* pmem = (BYTE*)GlobalLock(m_hMem);
	memcpy(pmem,pData,leng);
	IStream* pstm;
	CreateStreamOnHGlobal(m_hMem,TRUE,&pstm);
	// load from stream
	*img=Gdiplus::Image::FromStream(pstm);
	// free/release stuff
	GlobalUnlock(m_hMem);
	pstm->Release();
	}
	catch(...)
	{
	}
}

void LoadImageFromBuf(Image **img, CString path)
{
	try
	{
		CFile fp;
		if(fp.Open (path, CFile::modeRead))
		{
			DWORD leng=fp.GetLength ();
			BYTE *pData=new BYTE[leng];
			fp.Read (pData, leng);
			fp.Close ();
			LoadImageFromBuf(img, pData, leng);
			delete []pData;
		}
	}
	catch(...)
	{
	}
}
void LoadImageFromRes(Image **img, LPCTSTR lpszResourceName, LPCTSTR ResourceType)
{
	try
	{
  HGLOBAL  hGlobal = NULL;
  HRSRC  hSource = NULL;
  LPVOID  lpVoid  = NULL;
  int   nSize   = 0;
  BOOL  bResult=FALSE;
  hSource = FindResource(NULL, lpszResourceName, ResourceType);
  if(hSource == NULL)return;
  hGlobal = LoadResource(NULL, hSource);
  if(hGlobal == NULL)return;
  lpVoid = LockResource(hGlobal);
  if(lpVoid == NULL)return;

 nSize = (UINT)SizeofResource(NULL, hSource);
 LoadImageFromBuf(img, (BYTE*)hGlobal, nSize);
 UnlockResource(hGlobal); // 16Bit Windows Needs This
 FreeResource(hGlobal); // 16Bit Windows Needs This (32Bit - Automatic Release)
	}
	catch(...)
	{
	}
}
extern void RectFitDes(int width, int height, CRect &rc);
extern void SaveImageToFile(Image *img, CString path);
void GenSPhoto(CString dir)
{
	using namespace helper_coffs;
	ffsco o;
	o.dirs(1);
	o.find(LPCSTR(dir), LPCSTR("*.jpg"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_file();
	CString path,temp,spath;
	for (it = coo.begin();
	coo.end() != it;
	it ++) 
	{
		try
		{
		if(g_pMainWnd->m_bTerminate)return;
	 
		path=(*it).c_str();
		spath=path.Left (path.ReverseFind ('\\')+1);
		spath+="s";
		temp=path.Right (path.GetLength ()-path.ReverseFind ('\\')-1);
		if(temp.GetAt (0)=='s')continue;
		spath+=path.Right (path.GetLength ()-path.ReverseFind ('\\')-1);
		if(!CheckFileExist (spath))
		{
			Image *pImg=NULL;
			::LoadImageFromBuf(&pImg, path);
			if(pImg->GetWidth()==0)continue;
 
			CRect rc(0,0,100,90);
			RectFitDes(pImg->GetWidth(), pImg->GetHeight(), rc);
			Image *simg=pImg->GetThumbnailImage(rc.Width (), rc.Height (), NULL, NULL);
			Graphics graphic(simg);//防止GetThumbnailImage影响质量
			graphic.Clear(Color(255,255,255,255));
			graphic.DrawImage(pImg, 0,0,simg->GetWidth(), simg->GetHeight() ); 
///////////////////////////////
 	UINT totalBufferSize;
		UINT numProperties;
		pImg->GetPropertySize(&totalBufferSize, &numProperties);
		// Allocate the buffer that will receive the property items.
		PropertyItem* pAllItems = (PropertyItem*)malloc(totalBufferSize);
		// Fill the buffer.
		pImg->GetAllPropertyItems(totalBufferSize, numProperties, pAllItems);
		// Print the id data member of each property item.
		for(UINT j = 0; j < numProperties; ++j)
		{
			if(PropertyTagOrientation==pAllItems[j].id)
			{
				short* ptrLong = (short*)(pAllItems[j].value);
				int ret=(int)*ptrLong;
				if(ret==8)
					simg->RotateFlip( Rotate270FlipNone );
				else if(ret==6)
					simg->RotateFlip( Rotate90FlipNone );
				break;
			}
		
		}
		free(pAllItems); 
///////////////////////////////
			::SaveImageToFile (simg, spath);
			delete simg;
			delete pImg;
		}
	}
	catch(...)
	{
		WriteLogin("出错在函数GenSPhoto中");
	}
	}

	try
	{
	int oldsize=coo.size ();
	{
	ffsco o;
	o.dirs(1);
	o.find(LPCSTR(dir), LPCSTR("*.jpg"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_file();
	int newsize=coo.size ();
	if(oldsize==newsize)
	{
	path=dir+"\\ok";
	CFile fp;
	fp.Open (path, CFile::modeCreate|CFile::modeWrite);
	fp.Close ();
	}
	}
	}
	catch(...)
	{
		WriteLogin("出错在函数GenSPhoto2中");
	}
}

CString g_bakinfo;
CString g_bakphoto;
BOOL BakAllPhoto(CString dir, CString desdir, CString g_path1, CString g_path2, CString g_path3, CString g_path4)
{
	try
	{
    CString childdir;
	CString srcdir=dir;
	srcdir.MakeLower ();
	if(srcdir.Find (g_path1)!=-1)
	    childdir=srcdir.Right (srcdir.GetLength ()-g_path1.GetLength ());
	else if(srcdir.Find (g_path2)!=-1)
	    childdir=srcdir.Right (srcdir.GetLength ()-g_path2.GetLength ());
	else if(srcdir.Find (g_path3)!=-1)
	    childdir=srcdir.Right (srcdir.GetLength ()-g_path3.GetLength ());
	else if(srcdir.Find (g_path4)!=-1)
	    childdir=srcdir.Right (srcdir.GetLength ()-g_path4.GetLength ());
	else 
	{
		WriteLogin("备份出错-目录未找到!");
		return 0;
	}
/*	srcdir.TrimLeft ("\\");
	srcdir.Delete (srcdir.Find ('\\'));

	if(srcdir.Find ('\\')==-1)
		childdir="";
	else
		childdir=srcdir.Right (srcdir.GetLength ()-srcdir.Find ('\\'));*/
	childdir.TrimLeft ("\\");
	childdir.TrimRight ("\\");


	while(childdir.Find ('\\')!=-1)
	{
		desdir+="\\";
		desdir+=childdir.Left (childdir.Find ('\\'));
		//if(CheckFolderFileExist (desdir)==0)
		{
		//	if(!
				CreateDirectory (desdir, NULL);//)return;
		}
		childdir=childdir.Right (childdir.GetLength ()-childdir.Find ('\\')-1);
	}
	desdir+="\\";
	desdir+=childdir;
	//if(CheckFolderFileExist (desdir)==0)
	{
	//	if(!
			CreateDirectory (desdir, NULL);//)return;
	}
	desdir+="\\";
	using namespace helper_coffs;
	ffsco o;
	o.dirs(0);
	o.find(LPCSTR(dir), LPCSTR("*.*"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_file();
	CString path,temp,despath;
	for (it = coo.begin();
	coo.end() != it;
	it ++) 
	{
		try
		{
		if(g_pMainWnd->m_bTerminate2)return 0;
		path=(*it).c_str();
		temp=path.Right (path.GetLength ()-path.ReverseFind ('\\')-1);
		if(temp.GetAt (0)=='s')continue;
		despath=desdir+path.Right (path.GetLength ()-path.ReverseFind ('\\')-1);
		if(CheckFileExist (despath))
		{
		/*	HANDLE hFile=CreateFile(path,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
			HANDLE hFile2=CreateFile(despath,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
			FILETIME ftWrite,ftWrite2;
			if(GetFileTime(hFile, NULL, NULL, &ftWrite)==0)
			{	
				CloseHandle(hFile);
				CloseHandle(hFile2);
				return;
			}
			if(GetFileTime(hFile2, NULL, NULL, &ftWrite2)==0)
			{	
				CloseHandle(hFile);
				CloseHandle(hFile2);
				return;
			}
			CloseHandle(hFile);
			CloseHandle(hFile2);
			if(ftWrite.dwHighDateTime!=ftWrite2.dwHighDateTime || ftWrite.dwLowDateTime!=ftWrite2.dwLowDateTime)
			{*/
				if(::CopyFile (path, despath, 0))
					g_bakphoto="照片备份成功";
		//	}
		}
		else
		{
			if(::CopyFile (path, despath, 0))
				g_bakphoto="照片备份成功";
		}
		}
		catch(...)
		{
		}
	}
	}
	catch(...)
	{
		WriteLogin("出错在函数BakAllPhoto中");
		return 0;
	}
	return 1;
}

int FindArray(CStringArray *pArray, CString Str)
{
	for(int i=0; i<pArray->GetSize (); i++)
	{
		if(pArray->ElementAt (i)==Str)
			return i;
	}
	return -1;
}

unsigned __stdcall LoadThumbNail(LPVOID lpParam)
{
	CDBServerDlg *pDlg=(CDBServerDlg*)lpParam;
	try
	{
	CString g_path1;
	CString g_path2;
	CString g_path3;
	CString g_path4;
	char server[50];
	DWORD leng=50;
	::GetComputerName (server, &leng);	
 
	g_path1=g_path2=g_path3=g_path4=server; 
 

 
	if(g_path2.IsEmpty ())return 0;
	g_path1="\\\\"+g_path1+"\\客户原片(管理软件)$";
	g_path2="\\\\"+g_path2+"\\修好的片(管理软件)$";
	g_path3="\\\\"+g_path3+"\\设计好的片(管理软件)$";
	g_path4="\\\\"+g_path4+"\\精修好的片(管理软件)$";
  
 	g_path1=GetPathFromNetShareName("客户原片(管理软件)$");
	g_path2=GetPathFromNetShareName("修好的片(管理软件)$");
	g_path3=GetPathFromNetShareName("设计好的片(管理软件)$");
	g_path4=GetPathFromNetShareName("精修好的片(管理软件)$");


	CStringArray dirarray;

	CString path,path2;
	using namespace helper_coffs;
	CString patharray[4]={g_path1,g_path2,g_path3,g_path4};
	for(int i=0; i<4; i++)
	{
		if(pDlg->m_bTerminate)
		{
			break;
		}
 
	ffsco o;
	o.dirs(1);
	o.find(LPCSTR(patharray[i]), LPCSTR("*.*"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_dir();
	it = coo.begin();
	it ++;
	for (;
	coo.end() != it;
	it ++) 
	{	
		if(pDlg->m_bTerminate)
		{
			break;
		}
		path=(*it).c_str();
		path.TrimRight ("\\");
		path2=path;
		path2+="\\ok2";
		path+="\\ok"; 
		if(CheckFileExist (path2) && path2.Find (".ly.com")==-1)
		{
			::DeleteFile (path);::DeleteFile (path2);
		}
		
		if(g_bCheckAll)
		{
			if(FindArray(&dirarray, (*it).c_str())==-1)
				dirarray.Add ((*it).c_str());
		}
		else if(CheckFileExist (path)==0)
		{
			if(FindArray(&dirarray, (*it).c_str())==-1)
				dirarray.Add ((*it).c_str());
		}
	}
	}

	for(  i=0; i<dirarray.GetSize (); i++)
	{
		if(pDlg->m_bTerminate)
		{
			break;
		}
	 	GenSPhoto(dirarray.ElementAt (i));
	}
	}
	catch(...)
	{
		WriteLogin("出错在函数GenThumb中");
	}
	pDlg->m_bRunning=false;
	pDlg->m_bTerminate=false;
	pDlg-> SetTimer (1, 60*1000, NULL);
 
	_endthreadex( 0 );
	return 0;
}

BOOL isInnerIP( DWORD a_ip )
{
       BOOL bValid = 0;
       if( (a_ip>>24 == 0xa) || (a_ip>>16 == 0xc0a8) || (a_ip>>22 == 0x2b0) )
       {
          bValid = 1;
       }
       return bValid;
}
BOOL CompareIP(CString name1, CString name2)
{
	CStringArray g_serverarray1;
	CStringArray g_serverarray2;
	CString strIP=name1;
	DWORD dwServerIP=0;
	HOSTENT   *host   =   gethostbyname(strIP); 
	struct   in_addr   addr; 
	if   (host   !=   NULL) 
	{ 
		for(int i   =   0;   host-> h_addr_list[i]   !=   NULL;   i   ++) 
		{ 
			memset(&addr,   0,   sizeof(addr)); 
			memcpy(&addr.S_un.S_addr,   host-> h_addr_list[i],   host-> h_length); 
			dwServerIP   =   ntohl(addr.S_un.S_addr); 	
			BYTE*   pIP   =   (BYTE*)&dwServerIP; 
			strIP.Format(_T("%d.%d.%d.%d"),   pIP[3],   pIP[2],   pIP[1],   pIP[0]); 
			g_serverarray1.Add (strIP);
		}
	}
	while(g_serverarray1.GetSize ()>1)
	{
		CString name;
		BOOL bFind=0;
		for(int i=0; i<g_serverarray1.GetSize (); i++)
		{
			DWORD dwServerIP=inet_addr(g_serverarray1.ElementAt (i));
			dwServerIP=htonl(dwServerIP);//加了才正确
			if( isInnerIP(dwServerIP)==0 )
			{
				g_serverarray1.RemoveAt (i);
				bFind=1;
				break;
			}
		}
		if(bFind==0)
		{
			break;
		}
	}
//////////
	{
	CString strIP=name2;
	DWORD dwServerIP=0;
	HOSTENT   *host   =   gethostbyname(strIP); 
	struct   in_addr   addr; 
	if   (host   !=   NULL) 
	{ 
		for(int i   =   0;   host-> h_addr_list[i]   !=   NULL;   i   ++) 
		{ 
			memset(&addr,   0,   sizeof(addr)); 
			memcpy(&addr.S_un.S_addr,   host-> h_addr_list[i],   host-> h_length); 
			dwServerIP   =   ntohl(addr.S_un.S_addr); 	
			BYTE*   pIP   =   (BYTE*)&dwServerIP; 
			strIP.Format(_T("%d.%d.%d.%d"),   pIP[3],   pIP[2],   pIP[1],   pIP[0]); 
			g_serverarray2.Add (strIP);
		}
	}
	while(g_serverarray2.GetSize ()>1)
	{
		CString name;
		BOOL bFind=0;
		for(int i=0; i<g_serverarray2.GetSize (); i++)
		{
			DWORD dwServerIP=inet_addr(g_serverarray2.ElementAt (i));
			dwServerIP=htonl(dwServerIP);//加了才正确
			if( isInnerIP(dwServerIP)==0 )
			{
				g_serverarray2.RemoveAt (i);
				bFind=1;
				break;
			}
		}
		if(bFind==0)
		{
			break;
		}
	}
	}
	if(g_serverarray1.GetSize ()==0 || g_serverarray2.GetSize ()==0)return 1;
	for(int i=0; i<g_serverarray1.GetSize (); i++)
	{
		for(int j=0; j<g_serverarray2.GetSize (); j++)
		{
			if(g_serverarray1.ElementAt (i)==g_serverarray2.ElementAt (j))return 0;
		}
	}
	return 1;
}

DWORD g_tisks=0;
unsigned __stdcall LoadThumbNail2(LPVOID lpParam)//备份
{
	CDBServerDlg *pDlg=(CDBServerDlg*)lpParam;
	int step=1;
	try
	{
	g_tisks=::GetTickCount ();
	WriteLogin("开始备份照片");
	g_curdb=&g_db;
//	CRstPath rsSt;
	CString g_path1;
	CString g_path2;
	CString g_path3;
	CString g_path4;

 
	g_path1=g_path2=g_path3=g_path4=g_localname;
	CString localname=g_localname;

 

	g_path1="\\\\"+g_path1+"\\客户原片(管理软件)$";
	g_path2="\\\\"+g_path2+"\\修好的片(管理软件)$";
	g_path3="\\\\"+g_path3+"\\设计好的片(管理软件)$";
	g_path4="\\\\"+g_path4+"\\精修好的片(管理软件)$";

 	g_path1=GetPathFromNetShareName("客户原片(管理软件)$");
	g_path2=GetPathFromNetShareName("修好的片(管理软件)$");
	g_path3=GetPathFromNetShareName("设计好的片(管理软件)$");
	g_path4=GetPathFromNetShareName("精修好的片(管理软件)$"); 
	step=2;
	g_path1.MakeLower ();
	g_path2.MakeLower ();
	g_path3.MakeLower ();
	g_path4.MakeLower ();

	CString	m_bak1,m_bak2,m_bak3,m_bak4;
	CString	m_bak11,m_bak22,m_bak33,m_bak44;
	CString	m_bakserver1,m_bakserver2,m_bakserver3,m_bakserver4;
	{
	MyLock lock("dbaccessxiao");
 	CRstversion rsSt;
	rsSt.Open();
	if(!rsSt.IsEOF())
	{
 		m_bak1=rsSt.m_bak1;
 		m_bak2=rsSt.m_bak2;
		m_bak3=rsSt.m_bak3;
		m_bak4=rsSt.m_bak4; 
  		m_bakserver1=rsSt.m_bakserver1;
 		m_bakserver2=rsSt.m_bakserver2;
		m_bakserver3=rsSt.m_bakserver3;
		m_bakserver4=rsSt.m_bakserver4; 
  		m_bak11=rsSt.bak11;
 		m_bak22=rsSt.bak22;
		m_bak33=rsSt.bak33;
		m_bak44=rsSt.bak44; 
	}
	rsSt.Close(); 
	step=3;
	}
#ifdef CHILD_VERSION
	if((localname.CompareNoCase (m_bakserver1)==0 || CompareIP(localname, m_bakserver1)==0) && CheckFolderFileExist("\\\\"+m_bakserver1+"\\客户原片备份(儿童管理软件)$"))
		m_bakserver1=GetPathFromNetShareName("客户原片备份(儿童管理软件)$");
	else
		m_bakserver1="\\\\"+m_bakserver1+"\\客户原片备份(儿童管理软件)$";
	if((localname.CompareNoCase (m_bakserver2)==0 || CompareIP(localname, m_bakserver2)==0)  && CheckFolderFileExist("\\\\"+m_bakserver1+"\\修好的片备份(儿童管理软件)$"))
		m_bakserver2=GetPathFromNetShareName("修好的片备份(儿童管理软件)$");
	else
		m_bakserver2="\\\\"+m_bakserver2+"\\修好的片备份(儿童管理软件)$";
	if((localname.CompareNoCase (m_bakserver3)==0 || CompareIP(localname, m_bakserver3)==0)  && CheckFolderFileExist("\\\\"+m_bakserver1+"\\精修好的片备份(儿童管理软件)$"))
		m_bakserver3=GetPathFromNetShareName("精修好的片备份(儿童管理软件)$");
	else
		m_bakserver3="\\\\"+m_bakserver3+"\\精修好的片备份(儿童管理软件)$";
	if((localname.CompareNoCase (m_bakserver4)==0 || CompareIP(localname, m_bakserver4)==0)  && CheckFolderFileExist("\\\\"+m_bakserver1+"\\设计好的片备份(儿童管理软件)$"))
		m_bakserver4=GetPathFromNetShareName("设计好的片备份(儿童管理软件)$");
	else
		m_bakserver4="\\\\"+m_bakserver4+"\\设计好的片备份(儿童管理软件)$";
#else
	if((localname.CompareNoCase (m_bakserver1)==0 || CompareIP(localname, m_bakserver1)==0)  && CheckFolderFileExist("\\\\"+m_bakserver1+"\\客户原片备份(管理软件)$"))
		m_bakserver1=GetPathFromNetShareName("客户原片备份(管理软件)$");
	else
		m_bakserver1="\\\\"+m_bakserver1+"\\客户原片备份(管理软件)$";
	if((localname.CompareNoCase (m_bakserver2)==0 || CompareIP(localname, m_bakserver2)==0)  && CheckFolderFileExist("\\\\"+m_bakserver1+"\\修好的片备份(管理软件)$"))
		m_bakserver2=GetPathFromNetShareName("修好的片备份(管理软件)$");
	else
		m_bakserver2="\\\\"+m_bakserver2+"\\修好的片备份(管理软件)$";
	if((localname.CompareNoCase (m_bakserver3)==0 || CompareIP(localname, m_bakserver3)==0)  && CheckFolderFileExist("\\\\"+m_bakserver1+"\\精修好的片备份(管理软件)$"))
		m_bakserver3=GetPathFromNetShareName("精修好的片备份(管理软件)$");
	else
		m_bakserver3="\\\\"+m_bakserver3+"\\精修好的片备份(管理软件)$";
	if((localname.CompareNoCase (m_bakserver4)==0 || CompareIP(localname, m_bakserver4)==0)  && CheckFolderFileExist("\\\\"+m_bakserver1+"\\设计好的片备份(管理软件)$"))
		m_bakserver4=GetPathFromNetShareName("设计好的片备份(管理软件)$");
	else
		m_bakserver4="\\\\"+m_bakserver4+"\\设计好的片备份(管理软件)$";
#endif
	step=4;
	CStringArray dirarray;
	CString str,path;
	using namespace helper_coffs;
	BOOL bcheck1=atoi(m_bak1);
	BOOL bcheck2=atoi(m_bak2);
	BOOL bcheck3=atoi(m_bak3);
	BOOL bcheck4=atoi(m_bak4);
	BOOL bcheck11=atoi(m_bak11);
	BOOL bcheck22=atoi(m_bak22);
	BOOL bcheck33=atoi(m_bak33);
	BOOL bcheck44=atoi(m_bak44);


	CString patharray[4]={g_path1,g_path2,g_path4,g_path3};
	BOOL bcheck[4]={bcheck1,bcheck2,bcheck3,bcheck4};
	BOOL bcheckbranch[4]={bcheck11,bcheck22,bcheck33,bcheck44};
	CString patharray2[4]={m_bakserver1,m_bakserver2,m_bakserver3,m_bakserver4};
	CArray<int,int>posarray;
	for(int i=0; i<4; i++)
	{
		if(pDlg->m_bTerminate2)
		{
			break;
		}
	//	if(!CheckFolderFileExist (patharray[i]))continue;
	//	if(!CheckFolderFileExist (patharray2[i]))continue;	
		if(bcheck[i]==0)continue;
		if(!::CheckFolderFileExist (patharray2[i]))continue;
		if(!::CheckFolderFileExist (patharray[i]))continue;



	ffsco o;
	o.dirs(1);
	o.find(LPCSTR(patharray[i]), LPCSTR("*.*"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_dir();

	it = coo.begin();
	it ++;
	for (;
	coo.end() != it;
	it ++) 
	{
		if(pDlg->m_bTerminate2)
		{
			break;
		}
		str=(*it).c_str();
		if(str.Find (".ly.com")!=-1 && bcheckbranch[i]==0)continue;
		if(FindArray(&dirarray, str)==-1)
		{
			dirarray.Add (str);
			posarray.Add (i);
		}
	}
	}
	step=5;
	BOOL bError=0;
	for(  i=0; i<dirarray.GetSize (); i++)	
	{
		if(pDlg->m_bTerminate2)break;
		CTime tm=CTime::GetCurrentTime ();
		tm-=CTimeSpan(10, 0, 0, 0);
		CString date=tm.Format ("%Y%m%d");
		DWORD dirdate=GetLastDirTime(dirarray.ElementAt (i)); 
		if(pDlg->m_bTerminate2)break;
		CString ss;
		if(dirdate>atol(date))
		{
		//	ss.Format ("%d>%d", dirdate, atol(date));
		//	WriteLogin(ss);
		//	WriteLogin(dirarray.ElementAt (i));
			step=6;
		   	if(0==BakAllPhoto(dirarray.ElementAt (i), patharray2[posarray.ElementAt (i)], g_path1, g_path2, g_path3, g_path4))
				bError=1;

		CString path=dirarray.ElementAt (i);
		path.TrimRight ("\\");path+="\\";
		path+="modifytime";
		CStdioFile fp;
 
		if(!::PathFileExists (path))
		{ 
			fp.Open (path,CFile::modeCreate|CFile::modeWrite);
			fp.WriteString (CTime::GetCurrentTime ().Format ("%Y-%m-%d"));
			fp.Close ();
		}

		}
		else
		{
			step=7;
		CString path=dirarray.ElementAt (i);
		path.TrimRight ("\\");path+="\\";
		path+="modifytime";
		CStdioFile fp;
		if(!::PathFileExists (path))
		{
			step=8;
			fp.Open (path,CFile::modeCreate|CFile::modeWrite);
			fp.WriteString (CTime::GetCurrentTime ().Format ("%Y-%m-%d"));
			fp.Close ();
		}

		}
	}
	if(bError)
		g_bakphoto="照片备份失败";
	else
		g_bakphoto="照片备份成功";
	step=9;


	}
	catch(...)
	{
		CString ss;
		ss.Format ("出错在函数备份照片中-step:%d", step);
		WriteLogin(ss);
		g_bakphoto="照片备份出错";
	}
 
	pDlg-> SetTimer (6, 3000, NULL);
	pDlg->m_bRunning2=false;
	pDlg->m_bTerminate2=false;
	_endthreadex( 0 );
	return 0;
}

void CDBServerDlg::LoadThumbImages()
{
	if(m_bRunning)return;
	TerminateThread();
	m_bRunning=true;
 	m_hThread = (HANDLE)_beginthreadex(NULL,0, LoadThumbNail,(LPVOID)this,0/* CREATE_SUSPENDED*/,&m_dwThreadID); 
}

void CDBServerDlg::LoadThumbImages2()
{
	if(m_bRunning2)return;
	TerminateThread2();
	m_bRunning2=true;
 	m_hThread2 = (HANDLE)_beginthreadex(NULL,0, LoadThumbNail2,(LPVOID)this,0/* CREATE_SUSPENDED*/,&m_dwThreadID2); 
}

BOOL CDBServerDlg::TerminateThread()
{
	try
	{
	if ( !m_bRunning )
    return TRUE;
  
  m_bTerminate=true;
 
  for( ; ; )
  {
    if ( ::WaitForSingleObject(m_hThread, 0) == WAIT_OBJECT_0 )
      break;
 
    MSG msg;
    while (::PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)) 
    { 
      if (!AfxGetApp()->PumpMessage()) 
        break; 
    } 
  }
  ::CloseHandle(m_hThread); 
  m_bRunning=false;
  return TRUE;
	}
	catch(...)
	{
		WriteLogin("出错在函数TerminateThread中");
	}
}
BOOL CDBServerDlg::TerminateThread2()
{
	try
	{
	if ( !m_bRunning2 )
    return TRUE;
  
  m_bTerminate2=true;
 
  for( ; ; )
  {
    if ( ::WaitForSingleObject(m_hThread2, 0) == WAIT_OBJECT_0 )
      break;
    MSG msg;
    while (::PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)) 
    { 
      if (!AfxGetApp()->PumpMessage()) 
        break; 
    } 
  }
  ::CloseHandle(m_hThread2); 
  m_bRunning2=false;
  return TRUE;
	}
	catch(...)
	{
		WriteLogin("出错在函数TerminateThread2中");
	}
}

typedef struct tagresdata2
{
	BOOL bHasBk;
	int  nPicCount;	
	int  nPicCount2;
	DWORD nPicBmpCount[50];
	CRect rect[50];
}RESDATA2;

void DeCodePicCount(long &value1, long &value2)
{
	SoftKey ytSoftKey;
	int ret=ytSoftKey.Ini();
	if (ret!=0 )
	{
		return;
	}
	long d[8];double f[8];
	TCHAR s0[50]=_T(""),s1[50]=_T(""),s2[50]=_T(""),s3[50]=_T(""),s4[50]=_T(""),s5[50]=_T(""),s6[50]=_T(""),s7[50]=_T("");
	//运行自定义函数
	ret=ytSoftKey.decryptpiccount(&value1,&value2,&d[2],&d[3],&d[4],&d[5],&d[6],&d[7],
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		exit(0);
	}
}
void DeCodelong1(long &value1, long &value2, long &value3, long &value4, long &value5, long &value6, long &value7, long &value8)
{
	SoftKey ytSoftKey;
	int ret=ytSoftKey.Ini();
	if (ret!=0 )
	{
		return;
	}

	double f[8];
	TCHAR s0[50]=_T(""),s1[50]=_T(""),s2[50]=_T(""),s3[50]=_T(""),s4[50]=_T(""),s5[50]=_T(""),s6[50]=_T(""),s7[50]=_T("");
	//运行自定义函数
	ret=ytSoftKey.decryptlong1(&value1,&value2,&value3,&value4,&value5,&value6,&value7,&value8,
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		exit(0);
	}
}
void DeCodelong2(long &value1, long &value2, long &value3, long &value4, long &value5, long &value6, long &value7, long &value8)
{
	SoftKey ytSoftKey;
	int ret=ytSoftKey.Ini();
	if (ret!=0 )
	{
		return;
	}

	double f[8];
	TCHAR s0[50]=_T(""),s1[50]=_T(""),s2[50]=_T(""),s3[50]=_T(""),s4[50]=_T(""),s5[50]=_T(""),s6[50]=_T(""),s7[50]=_T("");
	//运行自定义函数
	ret=ytSoftKey.decryptlong2(&value1,&value2,&value3,&value4,&value5,&value6,&value7,&value8,
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		exit(0);
	}
}
void DeCodelong3(long &value1, long &value2, long &value3, long &value4, long &value5, long &value6, long &value7, long &value8)
{
	SoftKey ytSoftKey;
	int ret=ytSoftKey.Ini();
	if (ret!=0 )
	{
		return;
	}

	double f[8];
	TCHAR s0[50]=_T(""),s1[50]=_T(""),s2[50]=_T(""),s3[50]=_T(""),s4[50]=_T(""),s5[50]=_T(""),s6[50]=_T(""),s7[50]=_T("");
	//运行自定义函数
	ret=ytSoftKey.decryptlong3(&value1,&value2,&value3,&value4,&value5,&value6,&value7,&value8,
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
 
		exit(0);
	}
}
void DeCodelong4(long &value1, long &value2, long &value3, long &value4, long &value5, long &value6, long &value7, long &value8)
{
	SoftKey ytSoftKey;
	int ret=ytSoftKey.Ini();
	if (ret!=0 )
	{
		exit(0);
	}

	double f[8];
	TCHAR s0[50]=_T(""),s1[50]=_T(""),s2[50]=_T(""),s3[50]=_T(""),s4[50]=_T(""),s5[50]=_T(""),s6[50]=_T(""),s7[50]=_T("");
	//运行自定义函数
	ret=ytSoftKey.decryptlong4(&value1,&value2,&value3,&value4,&value5,&value6,&value7,&value8,
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		exit(0);
	}
}
void CDBServerDlg::InitLia()
{
	try
	{
	BYTE *g_pData=NULL;DWORD g_nLeng; DWORD count2;
	BYTE code=104;

	CConnectSocket consock;
	consock.m_pConndb =&g_db;
 	consock.GetDataFromCode(code, &g_pData, g_nLeng, count2, "");


	if(g_nLeng==0)return ;
	DWORD readbytes=0;
 
CArray<DWORD,DWORD>g_lengarray;
CArray<DWORD,DWORD>g_btnlengarray;
BYTE *g_pointerarray=NULL;
DWORD pointleng;

	DWORD leng;
	memcpy(&leng, g_pData+readbytes, sizeof(DWORD) );
	readbytes+=sizeof(DWORD);
 
    BYTE *pFtData = new BYTE[leng];
 
	memcpy(pFtData, g_pData+readbytes, leng);
	readbytes+=leng;


	CMemFile memfile;
	memfile.Attach (pFtData, leng);
	CArchive ar(&memfile, CArchive::load);
	g_lengarray.Serialize (ar);
	ar.Close();
	memfile.Detach ();
 
	memcpy(&leng, g_pData+readbytes, sizeof(DWORD) );
	readbytes+=sizeof(DWORD);
    BYTE *pFtData2 = new BYTE[leng];
	memcpy(pFtData2, g_pData+readbytes, leng);
	readbytes+=leng;

	CMemFile memfile2;
	memfile2.Attach (pFtData2, leng);
	CArchive ar2(&memfile2, CArchive::load);
	g_btnlengarray.Serialize (ar2);
	ar2.Close();
	memfile2.Detach ();
 
	delete []pFtData;
	delete []pFtData2;

	DWORD count;
 	memcpy(&count, g_pData+readbytes, sizeof(DWORD) );
	readbytes+=sizeof(DWORD);
	pointleng=count*sizeof(RESDATA2);
	g_pointerarray=new BYTE[pointleng];
	for(int i=0; i<count; i++)
	{
		memcpy(g_pointerarray+i*sizeof(RESDATA2), g_pData+readbytes, sizeof(RESDATA2));
		readbytes+=sizeof(RESDATA2);
	}

    for( i=0; i<g_lengarray.GetSize (); i+=8)
	{
		DWORD leng1,leng2,leng3,leng4,leng5,leng6,leng7,leng8;
		leng1=g_lengarray.ElementAt (i);
		leng2=g_lengarray.ElementAt (i+1);
		leng3=g_lengarray.ElementAt (i+2);
		leng4=g_lengarray.ElementAt (i+3);
		leng5=g_lengarray.ElementAt (i+4);
		leng6=g_lengarray.ElementAt (i+5);
		leng7=g_lengarray.ElementAt (i+6);
		leng8=g_lengarray.ElementAt (i+7);
		if(i%4==0)
		   DeCodelong1( (long&)leng1, (long&)leng2, (long&)leng3, (long&)leng4, (long&)leng5, (long&)leng6, (long&)leng7, (long&)leng8 );
		else if(i%4==1)
		   DeCodelong2( (long&)leng1, (long&)leng2, (long&)leng3, (long&)leng4, (long&)leng5, (long&)leng6, (long&)leng7, (long&)leng8 );
		else if(i%4==2)
		   DeCodelong3( (long&)leng1, (long&)leng2, (long&)leng3, (long&)leng4, (long&)leng5, (long&)leng6, (long&)leng7, (long&)leng8 );
		else
		   DeCodelong4( (long&)leng1, (long&)leng2, (long&)leng3, (long&)leng4, (long&)leng5, (long&)leng6, (long&)leng7, (long&)leng8 );
		g_lengarray.SetAt (i, leng1);
		g_lengarray.SetAt (i+1, leng2);
		g_lengarray.SetAt (i+2, leng3);
		g_lengarray.SetAt (i+3, leng4);
		g_lengarray.SetAt (i+4, leng5);
		g_lengarray.SetAt (i+5, leng6);
		g_lengarray.SetAt (i+6, leng7);
		g_lengarray.SetAt (i+7, leng8);
	}
	delete []g_pData;

    if(g_pSkinData)delete []g_pSkinData;g_pSkinData=NULL;

	DWORD length;
	BYTE *pData;
	DWORD length2;
	BYTE *pData2;
	{
    CMemFile memfile;
	CArchive ar(&memfile, CArchive::store);
	g_lengarray.Serialize (ar);
 	ar.Close();
	length=memfile.GetLength ();
	pData = memfile.Detach();
	}
	{
    CMemFile memfile;
	CArchive ar(&memfile, CArchive::store);
	g_btnlengarray.Serialize (ar);
 	ar.Close();
	length2=memfile.GetLength ();
	pData2 = memfile.Detach();
	}
	g_SkinLeng=length+length2+pointleng+3*sizeof(DWORD);
	g_pSkinData=new BYTE[g_SkinLeng];
	  readbytes=0;

	memcpy(g_pSkinData+readbytes, &length, sizeof(DWORD));
	readbytes+=sizeof(DWORD);
	memcpy(g_pSkinData+readbytes, pData, length);	
	readbytes+=length;

	memcpy(g_pSkinData+readbytes, &length2, sizeof(DWORD));
	readbytes+=sizeof(DWORD);
	memcpy(g_pSkinData+readbytes, pData2, length2);	
	readbytes+=length2;

	memcpy(g_pSkinData+readbytes, &pointleng, sizeof(DWORD));
	readbytes+=sizeof(DWORD);
	memcpy(g_pSkinData+readbytes, g_pointerarray, pointleng);	
	readbytes+=pointleng;
	delete []g_pointerarray;
	}
	catch(...)
	{
		WriteLogin("出错在函数InitLia中");
	}
}

void CDBServerDlg::CheckHistoryData()
{
	try
	{
		if(g_bConvertHisAll)
		{
			DWORD id=FindAppProcessID("AutoRun.exe");
			if(id!=-1)
			{
				HANDLE ProcessHandle=OpenProcess(PROCESS_ALL_ACCESS,FALSE,id);
				if(ProcessHandle)TerminateProcess(ProcessHandle,0);
			}
			ShowWindow(SW_HIDE);
		}

    CString sql;
	g_curdb=&g_db;
	CTime tm=CTime::GetCurrentTime ();
	int lastyear=tm.GetYear ()-1;
	CString strdate,strdate2;
	strdate.Format ("%04d-%02d-%02d", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d", lastyear, 12, 31);
	CString filter="time1>='"+strdate+"' and time1<='"+strdate2+"' and status3='OK'";

	DWORD ii=0;
    CArray<CStringArray, CStringArray>g_List1array;
	{
 	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from dindan";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstDindanForm rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.id) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}

	CDatabase *pdb2=GetDB(lastyear);
	if(pdb2==NULL)CheckYear(lastyear);

	CDatabase *pdb1=&g_db;
	pdb2=GetDB(lastyear);
	if(pdb2==NULL)return;
	for(int i=0; i<g_List1array.GetSize (); i++)
	{
		int ret=TransDinDan(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0));
		if(ret==1)
		{
			{
				sql= "delete from  dindan where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  dindansp where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  photoprint where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  dindanbukuan where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);
				sql= "delete from  dindanbukuan2 where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  client where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  burncdreg where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  digitalwork where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  mywork where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  dindanjd where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);

				sql= "delete from  dindansp2 where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);
				sql= "delete from  dindansp3 where id='"+g_List1array.ElementAt (i).ElementAt (0)+"'";
				MyExecuteSQL(&g_db, sql);
			}
		}
		else
		{
			sql.Format("ret:%d", ret);
			WriteLogin("转历史失败"+g_List1array.ElementAt (i).ElementAt (0)+sql);
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
 
////////////////////////////支出
	strdate.Format ("%04d-%02d-%02d", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d", lastyear, 12, 31);
	filter="dat>='"+strdate+"' and dat<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from gudingfeiyong";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstPayOutInput rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.id) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}

 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(TransPayOut(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  gudingfeiyong where id=%d", atol(g_List1array.ElementAt (i).ElementAt (0) ));
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
 
////////////////////////////其它收入
	strdate.Format ("%04d-%02d-%02d", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d", lastyear, 12, 31);
	filter="dat>='"+strdate+"' and dat<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from singleincome";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstIncomeInput rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		if(atoi(rsSt.balance)==0)
		    g_List1array.ElementAt (ii).Add(rsSt.id) ;
		else
		{rsSt.MoveNext();continue;
		}
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}

 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(TransIncome(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  singleincome where id=%d", atol(g_List1array.ElementAt (i).ElementAt (0) ));
				MyExecuteSQL(&g_db, sql);

				sql.Format ("delete from  singleincomemoney where [id]='%s'", g_List1array.ElementAt (i).ElementAt (0));
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
////////////////////////////其它二销收款
	filter="id not in(select id from singleincome)";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from singleincomemoney";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstsingleincomemoney rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.id) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
////////////////////////////其它二销收款
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(TransIncomeMoney(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  singleincomemoney where [id]='%s'", g_List1array.ElementAt (i).ElementAt (0));
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
if(i>20)break;
#endif
	}

///1/////////////////////////client2phonerecord 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from client2phonerecord";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstclient2phonerecord rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transclient2phonerecord(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  client2phonerecord where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////client2phonerecordout 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from client2phonerecordout";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstclient2phonerecordout rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transclient2phonerecordout(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  client2phonerecordout where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///1/////////////////////////client3phonerecord 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from client3phonerecord";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstclient3phonerecord rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transclient3phonerecord(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  client3phonerecord where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////client3phonerecordout 2010-08-09 16:22:16
 	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from client3phonerecordout";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstclient3phonerecordout rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transclient3phonerecordout(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  client3phonerecordout where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	} 
///////////////////////////
////////////////////////////employeephonerecord 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from employeephonerecord";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstemployeephonerecord rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transemployeephonerecord(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  employeephonerecord where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////employeephonerecordout 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from employeephonerecordout";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstemployeephonerecordout rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transemployeephonerecordout(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  employeephonerecordout where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////phonerecord 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from phonerecord";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstphonerecord rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transphonerecord(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  phonerecord where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////phonerecordout 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from phonerecordout";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstphonerecordout rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transphonerecordout(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  phonerecordout where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////unknownphonerecord 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from unknownphonerecord";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstunknownphonerecord rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transunknownphonerecord(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  unknownphonerecord where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////unknownphonerecordout 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from unknownphonerecordout";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstunknownphonerecordout rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transunknownphonerecordout(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  unknownphonerecordout where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////misscallrecord 2010-08-09 16:22:16
	strdate.Format ("%04d-%02d-%02d 00:00:00", lastyear, 1, 1);
	strdate2.Format ("%04d-%02d-%02d 99:99:99", lastyear, 12, 31);
	filter="datetime>='"+strdate+"' and datetime<='"+strdate2+"'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from misscallrecord";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstmisscallrecord rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.datetime) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(Transmisscallrecord(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  misscallrecord where datetime='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
////////////////////////////sendreg
	strdate.Format ("%04d%02d%02d000000", lastyear, 1, 1);
	strdate2.Format ("%04d%02d%02d999999", lastyear, 12, 31);
	filter="timestamp>='"+strdate+"' and timestamp<='"+strdate2+"' and issended='OK'";
	{
	g_List1array.RemoveAll ();
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from sendreg";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	RstSendReg rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.m_timestamp) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );
	}
 	for( i=0; i<g_List1array.GetSize (); i++)
	{
		if(TransSendReg(pdb1, pdb2, g_List1array.ElementAt (i).ElementAt (0)))
		{
			{
				sql.Format ("delete from  sendreg where [timestamp]='%s'", g_List1array.ElementAt (i).ElementAt (0) );
				MyExecuteSQL(&g_db, sql);
			}
		}
#ifdef LIMITCOUNT 
		if(g_bConvertHisAll==0)
		{
			if(i>10)break;
		}
#endif
	}
///////////////////////////
	}
	catch(...)
	{
		WriteLogin("出错在函数TransHisData中");
	}
	g_bConvertHisAll=0;
/////////////////////////生成来电精灵数据
//return;
/*	g_sendhead.code[0]=80;
	g_sendhead.code[1]=90;
	g_sendhead.code[2]=11;
	g_sendhead.code[3]=138;
	g_sendhead.code[4]=24;
	g_sendhead.code[0]=181;
 	g_sendhead.code[0]=65;
 	g_sendhead.code[0]=56;*/
	MyLock lock("processChatMessageRequestxiao");
	CArray<int,int>codearray;
	codearray.Add (80);
	codearray.Add (90);
	codearray.Add (11);
	codearray.Add (138);
	codearray.Add (24);
	codearray.Add (181);
	codearray.Add (65);
 	codearray.Add (56); 
	codearray.Add (179);
 	codearray.Add (53); 
	CFile fp;
	CString savepath,g_path1;
 	g_path1=GetPathFromNetShareName("电话录音(管理软件)$");
	if(g_path1.IsEmpty ())return;

	try
	{
	CArray<CDatabase*,CDatabase*>dbarraytemp;
	dbarraytemp.Copy(dbarray);
	dbarraytemp.InsertAt(0, &g_db);
 
	for(int aa=0; aa<dbarraytemp.GetSize (); aa++)
	{
		g_curdb=dbarraytemp.ElementAt (aa);
	    savepath.Format ("%s\\uphonedata%d.dat", g_path1, aa);
	::DeleteFile (savepath);
	if(fp.Open (savepath, CFile::modeCreate|CFile::modeWrite)==0)
	{
		WriteLogin("更新电精灵数据出错");
		return;
	}
	CConnectSocket consock;
	consock.m_pConndb =g_curdb;


	for(int i=0; i<codearray.GetSize (); i++)
	{
		BYTE code=codearray.ElementAt (i);
		DWORD length,arraysize;
		BYTE *pReturn=NULL;
		consock.GetDataFromCode(code, &pReturn, length, arraysize, "");
		fp.Write (&code, sizeof(BYTE));
		fp.Write (&length, sizeof(DWORD));
		fp.Write (&arraysize, sizeof(DWORD));
		fp.Write (pReturn, length);
	}
	fp.Close ();
	}
	g_curdb=&g_db;
	}
	catch(...)
	{
		WriteLogin("获取来电精灵数据出错");
	}
}

void CDBServerDlg::CheckYear(int year)
{
	try
	{
#ifdef SQLSERVER_VERSION
	CString path,path2,sql;
	path.Format ("%s\\数据\\%d.mdf", g_mainpath, year);
	path2.Format ("%s\\数据\\%d_log.LDF", g_mainpath, year);
	{
		CString nulldb=g_mainpath+"\\数据\\dbnull.mdf";
		if(::PathFileExists (nulldb)==0)
		{
			WriteLogin("空数据库丢失!");
			return;
		}
		::CopyFile (nulldb, path, 1);

	 
		if(::PathFileExists(path)==0 )
		{
			WriteLogin("拷贝数据库文件失败!");
			return;
		}
		BOOL bLog=0;
 		if( ::PathFileExists(path2))
		{
			bLog=1;
		}  

 
		CString sql;
		if(bLog)
	 	    sql.Format("exec sp_attach_db '%d',@filename1='%s',@filename2='%s'", year, path, path2);
		else
		    sql.Format("exec sp_attach_db '%d',@filename1='%s'", year, path);
 
		g_db.SetQueryTimeout(600);
		try
		{
			g_db.ExecuteSQL (sql);   
		}
		catch(CDBException * e)
		{
			WriteLogin(e->m_strError);
			WriteLogin("历史数据库初始化失败!");
		}
g_db.SetQueryTimeout(100);

		CDatabase *db=new CDatabase;
 
 
		try
		{
		CString strCon;			
		strCon.Format(_T("driver={SQL Server};Server=%s\\SQLEXPRESS;DATABASE=%d;UID=sa;PWD=ly1234;"), g_localname, year);
		db->OpenEx(strCon,CDatabase::noOdbcDialog);
		 
			yeararray.Add (year);
			dbarray.Add (db);
			sql.Format ("insert into [historydb]([year])values('%d')", year);
			MyExecuteSQL(&g_db, sql);
		}
		catch(CDBException * e)
		{
			delete db;
 			WriteLogin(e->m_strError);
			WriteLogin("历史数据库打开失败!");
		}
	}
#else
	CString path,sql;
	path.Format ("%s\\数据\\%d.mdb", g_mainpath, year);
	if(::PathFileExists (path)==0)
	{
		CString nulldb=g_mainpath+"\\数据\\dbnull.mdb";
		::CopyFile (nulldb, path, 1);
		CDatabase *db=new CDatabase;
		CString strCon;
		strCon.Format("DRIVER=Microsoft Access Driver (*.mdb);DSN='';DBQ=%s;PWD=lijialyfz",path);
		if(db->OpenEx(strCon,CDatabase::noOdbcDialog))
		{
			yeararray.Add (year);
			dbarray.Add (db);
			sql.Format ("insert into historydb([year])values('%d')", year);
			MyExecuteSQL(&g_db, sql);
		}
		else
	    	delete db;
	}
#endif
	}
	catch(...)
	{
		WriteLogin("出错在函数CheckYear中");
	}
}

CDatabase* CDBServerDlg::GetDB(int year)
{
	try
	{
	for(int i=0; i<yeararray.GetSize (); i++)
	{
		if(yeararray.ElementAt (i)==year)
		{
			return dbarray.ElementAt (i);
		}
	}
	return NULL;
	}
	catch(...)
	{
		WriteLogin("出错在函数GetDB中");
	}
}

BOOL CDBServerDlg::CheckDinDanExist(CDatabase *pdb1, CDatabase *pdb2, CString id, CStringArray *pretarray)
{
	try
	{
	pretarray->RemoveAll();
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from dindan where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from dindan where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from dindansp where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from dindansp where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from dindanbukuan where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from dindanbukuan where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from dindanbukuan2 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from dindanbukuan2 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from photoprint where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from photoprint where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from client where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from client where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from burncdreg where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from burncdreg where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from digitalwork where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from digitalwork where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from mywork where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from mywork where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from dindanjd where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from dindanjd where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from dindansp2 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from dindansp2 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from dindansp3 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from dindansp3 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");
	for(int i=0; i<pretarray->GetSize (); i++)
	{
		if(pretarray->ElementAt (i)=="0")return 0;
	}
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check1中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckPayOutExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql.Format("select count(*) as cot from gudingfeiyong where [id]=%d", atol(id));
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from gudingfeiyong where [id]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check2中");
	}
	return 0;
}
BOOL CDBServerDlg::CheckIncomeExist(CDatabase *pdb1, CDatabase *pdb2, CString id, CStringArray *pretarray)
{
	try
	{	
	pretarray->RemoveAll();
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql.Format("select count(*) as cot from singleincome where [id]=%d", atol(id));
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from singleincome where [id]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");


	{
	CRecordset myset(pdb1);
	sql.Format("select count(*) as cot from singleincomemoney where [id]='%s'", id);
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql.Format("select count(*) as cot from singleincomemoney where [id]='%s'", id);
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)
		pretarray->Add ("0");
	else
		pretarray->Add ("1");



	for(int i=0; i<pretarray->GetSize (); i++)
	{
		if(pretarray->ElementAt (i)=="0")return 0;
	}
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckIncomeMoneyExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql.Format("select count(*) as cot from singleincomemoney where [id]='%s'", id);
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql.Format("select count(*) as cot from singleincomemoney where [id]='%s'", id);
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
int CDBServerDlg::TransDinDan(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	int step=0;
	CStringArray retarray;
	try
	{
	CString	sql,str;
	if(CheckDinDanExist(pdb1, pdb2, id, &retarray))return 1;
 
	step=1;
	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	int ret=1;

	CRecordset myset(pdb1);
	try
	{
	if(retarray.ElementAt (0)=="0")
	{
	sql="select * from dindan where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
 
	sql="insert into dindan(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
 

	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		temp="";
		myset.GetFieldValue((short)i, temp);
		
	 /*   CDBVariant varField;
		myset.GetFieldValue((short)i, varField);
		if(varField.m_dwType== DBVT_STRING)
		   temp=*(varField.m_pstring);*/


		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
//	WriteLogin(sql);
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step2"+e->m_strError);
		ret=2;
	}

	step=2;
	try
	{
	if(retarray.ElementAt (1)=="0")
	{
	sql="select * from dindansp where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into dindansp(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step3"+e->m_strError);
		ret=3;
	}
 
	step=3;
	try
	{
	if(retarray.ElementAt (2)=="0")
	{
	sql="select * from dindanbukuan where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into dindanbukuan(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step4"+e->m_strError);
		ret=4;
	}

	step=4;
	try
	{
	if(retarray.ElementAt (3)=="0")
	{
	sql="select * from dindanbukuan2 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into dindanbukuan2(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step5"+e->m_strError);
		ret=5;
	}

	step=5;
	try
	{
	if(retarray.ElementAt (4)=="0")
	{
	sql="select * from photoprint where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into photoprint(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step6"+e->m_strError);
		ret=6;
	}

	step=6;
	try
	{
	if(retarray.ElementAt (5)=="0")
	{
	sql="select * from client where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into client(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step7"+e->m_strError);
		ret=7;
	}

	step=7;
	try
	{
	if(retarray.ElementAt (6)=="0")
	{
	sql="select * from burncdreg where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into burncdreg(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step8"+e->m_strError);
		ret=8;
	}


	step=8;
	try
	{
	if(retarray.ElementAt (7)=="0")
	{
	sql="select * from digitalwork where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into digitalwork(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step9"+e->m_strError);
		ret=9;
	}

	step=9;
	try
	{
	if(retarray.ElementAt (8)=="0")
	{
	sql="select * from mywork where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into mywork(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step10"+e->m_strError);
		ret=10;
	}

	step=10;
	try
	{
	if(retarray.ElementAt (9)=="0")
	{
	sql="select * from dindanjd where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into dindanjd(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step11"+e->m_strError);
		ret=11;
	}

	step=11;
	try
	{
	if(retarray.ElementAt (10)=="0")
	{
	sql="select * from dindansp2 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into dindansp2(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step12"+e->m_strError);
		ret=12;
	}

	step=12;
	try
	{
	if(retarray.ElementAt (11)=="0")
	{
	sql="select * from dindansp3 where id='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into dindansp3(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
 
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin("step13"+e->m_strError);
		ret=13;
	}
 
    if(ret!=1)return ret;
 
	return CheckDinDanExist(pdb1, pdb2, id, &retarray);
	}
	catch(...)
	{ 
		CString str;
		str.Format("%d size:%d", step, retarray.GetSize());
		WriteLogin("出错在函数trans1中-"+str);
	}	
	return 0;
}

BOOL CDBServerDlg::TransPayOut(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckPayOutExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from gudingfeiyong where [id]=%d", atol(id)); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into gudingfeiyong(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
    catch(CDBException * e)
    {
	    WriteLogin(e->m_strError);
		ret=0;
	}
    if(ret==0)return 0;
	return CheckPayOutExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans2中");
	}
	return 0;
}
//singleincome
BOOL CDBServerDlg::TransIncome(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;	
	CStringArray retarray;
	if(CheckIncomeExist(pdb1, pdb2, id, &retarray))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	if(retarray.ElementAt (0)=="0")
	{
	sql.Format("select * from singleincome where [id]=%d", atol(id)); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into singleincome(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
	catch(...)
	{
		ret=0;
	}

	try
	{
	if(retarray.ElementAt (1)=="0")
	{
	sql.Format("select * from singleincomemoney where [id]='%s'", id); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into singleincomemoney(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	}
    catch(CDBException * e)
    {
	    WriteLogin(e->m_strError);
		ret=0;
	}
    if(ret==0)return 0;
	return CheckIncomeExist(pdb1, pdb2, id, &retarray);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::TransIncomeMoney(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckIncomeMoneyExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from singleincomemoney where [id]='%s'", id); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into singleincomemoney(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
    catch(CDBException * e)
    {
	    WriteLogin(e->m_strError);
		ret=0;
	}
    if(ret==0)return 0;
	return CheckIncomeMoneyExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::Checkclient2phonerecordExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from client2phonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from client2phonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}

BOOL CDBServerDlg::Transclient2phonerecord(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(Checkclient2phonerecordExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from client2phonerecord where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into client2phonerecord(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return Checkclient2phonerecordExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}
BOOL CDBServerDlg::Checkclient3phonerecordExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from client3phonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from client3phonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}

BOOL CDBServerDlg::Transclient3phonerecord(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(Checkclient3phonerecordExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from client3phonerecord where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into client3phonerecord(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return Checkclient3phonerecordExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::Checkclient2phonerecordoutExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from client2phonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from client2phonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transclient2phonerecordout(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(Checkclient2phonerecordoutExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from client2phonerecordout where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into client2phonerecordout(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return Checkclient2phonerecordoutExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::Checkclient3phonerecordoutExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from client3phonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from client3phonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transclient3phonerecordout(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(Checkclient3phonerecordoutExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from client3phonerecordout where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into client3phonerecordout(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return Checkclient3phonerecordoutExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckemployeephonerecordExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from employeephonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from employeephonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transemployeephonerecord(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckemployeephonerecordExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from employeephonerecord where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into employeephonerecord(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return CheckemployeephonerecordExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckemployeephonerecordoutExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from employeephonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from employeephonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transemployeephonerecordout(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckemployeephonerecordoutExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from employeephonerecordout where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into employeephonerecordout(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return CheckemployeephonerecordoutExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckphonerecordExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from phonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from phonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transphonerecord(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckphonerecordExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from phonerecord where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into phonerecord(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return CheckphonerecordExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckphonerecordoutExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from phonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from phonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transphonerecordout(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckphonerecordoutExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from phonerecordout where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into phonerecordout(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return CheckphonerecordoutExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckunknownphonerecordExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from unknownphonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from unknownphonerecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transunknownphonerecord(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckunknownphonerecordExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from unknownphonerecord where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into unknownphonerecord(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return CheckunknownphonerecordExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckunknownphonerecordoutExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from unknownphonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from unknownphonerecordout where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transunknownphonerecordout(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckunknownphonerecordoutExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from unknownphonerecordout where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into unknownphonerecordout(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return CheckunknownphonerecordoutExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckmisscallrecordExist(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql="select count(*) as cot from misscallrecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql="select count(*) as cot from misscallrecord where [datetime]='"+id+"'";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}
BOOL CDBServerDlg::Transmisscallrecord(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckmisscallrecordExist(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from misscallrecord where [datetime]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into misscallrecord(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		sql+="["+fieldinfo.m_strName+"],";
	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return CheckmisscallrecordExist(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}

BOOL CDBServerDlg::CheckSendReg(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	int count1=0;
	int count2=0;
	CString sql;
	{
	CRecordset myset(pdb1);
	sql.Format("select count(*) as cot from sendreg where [timestamp]='%s'", id );
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count1=atoi(sql);
	}
	{
	CRecordset myset(pdb2);
	sql.Format("select count(*) as cot from sendreg where [timestamp]='%s'", id );
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	count2=atoi(sql);
	}
	if(count1>count2)return 0;
	return 1;
	}
	catch(...)
	{
		WriteLogin("出错在函数check3中");
	}
	return 0;
}

BOOL CDBServerDlg::TransSendReg(CDatabase *pdb1, CDatabase *pdb2, CString id)
{
	try
	{
	CString	sql;
	if(CheckSendReg(pdb1, pdb2, id))return 1;

	int i;CString temp;
	int colcount;
	CODBCFieldInfo fieldinfo;
	BOOL ret=1;
	CRecordset myset(pdb1);
	try
	{
	sql.Format("select * from sendreg where [timestamp]='%s'", id ); 
	myset.Open (CRecordset::forwardOnly, sql);
	int autoidpos=0;
	while(!myset.IsEOF ())
	{
	colcount=myset.GetODBCFieldCount ();
	sql="insert into sendreg(";
	for( i=0; i<colcount; i++)
	{
		myset.GetODBCFieldInfo(i, fieldinfo);
		if(fieldinfo.m_strName=="autoid")
		{
			autoidpos=i;
			continue;
		}
		sql+="["+fieldinfo.m_strName+"],";

	}
	sql.TrimRight (",");
	sql+=")values(";
	for( i=0; i<colcount; i++)
	{
		if(autoidpos==i)continue;
		myset.GetFieldValue(i, temp);
		sql+="'"+temp+"',";
	}
	sql.TrimRight (",");
	sql+=")";
	MyExecuteSQL(pdb2, sql);
	myset.MoveNext ();
	}
	myset.Close();
	}
	catch(...)
	{
		ret=0;
	}
    if(ret==0)return 0;
	return CheckSendReg(pdb1, pdb2, id);
	}
	catch(...)
	{
		WriteLogin("出错在函数trans3中");
	}
	return 0;
}
void CDBServerDlg::MyExecuteSQL(CDatabase* pdb, CString sql)
{
	try
	{
		MyLock lock("dbaccessxiao");
		pdb->ExecuteSQL (sql);
	}
	catch(...)
	{
	//	WriteLogin("出错在函数executesql中");
	}
}

void CDBServerDlg::UpdateDate()
{
	try
	{
/*	CString tm,sql;
	tm=CTime::GetCurrentTime ().Format ("%Y-%m-%d");
	sql.Format ("update version set curdate='%s'",tm);
	MyExecuteSQL(&g_db, sql);
 */

/*	CTime tm2=CTime::GetCurrentTime ();
	CTimeSpan dt2(365, 0, 0, 0);
	tm2-=dt2;
    tm=tm2.Format ("%Y%m%d%H%M%S");
	sql.Format ("delete from sendreg where timestamp<'%s'",tm);
	MyExecuteSQL(&g_db, sql);*/


	HWND hwnd=::FindWindow (NULL, "AutoRun.exe - 应用程序错误");
		if(hwnd)
		{
			HWND child=::FindWindowEx(hwnd, 0, NULL, "确定");
			CWnd	*pWnd = CWnd::FromHandle( child );
			::PostMessage( hwnd, WM_COMMAND, pWnd->GetDlgCtrlID(), (LPARAM) child );
		}
 
	CString autorunpath=g_mainpath+"\\AutoRun.exe";
	if(0==g_bConvertHisAll)
        ShellExecute(NULL, _T("open"), autorunpath, NULL, NULL,  SW_HIDE);

	autorunpath=g_mainpath+"\\MsgServer.exe";
    ShellExecute(NULL, _T("open"), autorunpath, NULL, NULL,  SW_HIDE);

#ifdef ENTERPRISE_VERSION
	autorunpath=g_mainpath+"\\DataSyncReceive.exe";
    ShellExecute(NULL, _T("open"), autorunpath, NULL, NULL,  SW_HIDE);
	autorunpath=g_mainpath+"\\DataSyncSend.exe";
    ShellExecute(NULL, _T("open"), autorunpath, NULL, NULL,  SW_HIDE);
	autorunpath=g_mainpath+"\\CPhotoFTPReceive.exe";
    ShellExecute(NULL, _T("open"), autorunpath, NULL, NULL,  SW_HIDE);
	autorunpath=g_mainpath+"\\CPhotoFTPSend.exe";
    ShellExecute(NULL, _T("open"), autorunpath, NULL, NULL,  SW_HIDE);
#endif
	}
	catch(...)
	{
		WriteLogin("出错在函数UpdateDate中");
	}
}

void WriteLogin(CString str)
{
	MyLock lock("CDBServerDlgWriteLogin");
	try
	{
	CStdioFile fp;
	CString path=g_mainpath+"\\日志.txt";
	if(CheckFileExist (path))
	{
		fp.Open (path, CFile::modeWrite);
		int length=fp.GetLength ();
		if(length>5*1024*1024)
		{
			fp.Close ();
			::DeleteFile (path);
			return;
		}
		fp.SeekToEnd ();
	}
	else
		fp.Open (path, CFile::modeCreate|CFile::modeWrite);
	fp.WriteString (CTime::GetCurrentTime ().Format ("%Y-%m-%d %H:%M:%S")+" "+str+"\n" );
	fp.Close ();
	}
	catch(...)
	{
	}
}

BOOL CheckDateOK(CString str)
{
	try
	{
	CString tip;
	int i;
	CString demo=CTime::GetCurrentTime ().Format ("%Y-%m-%d");
	if(str.GetLength ()!=demo.GetLength ())
		goto ll;
	//2009-01-01
	if(str.GetAt (4)!='-')
		goto ll;
	if(str.GetAt (7)!='-')
		goto ll;
	for( i=0; i<str.GetLength (); i++)
	{
		if(i==4 || i==7)continue;
		if(str.GetAt (i)<'0' || str.GetAt (i)>'9')
			goto ll;
	}
	return 1;
ll:
	return 0;
	}
	catch(...)
	{
		WriteLogin("出错");
	}
}

void CDBServerDlg::AutoDelPhoto()
{
	try
	{
	g_curdb=&g_db;

	CString	m_check1,m_check2,m_check3,m_check4;
	CString	m_edit1,m_edit2,m_edit3,m_edit4;
 
	CString	m_bakserver1,m_bakserver2,m_bakserver3,m_bakserver4;
	{
	CRstversion rsSt;
	rsSt.Open();
	if(!rsSt.IsEOF())
	{
		m_check1=rsSt.m_check1;
 		m_check2=rsSt.m_check2;
		m_check3=rsSt.m_check3;
		m_check4=rsSt.m_check4;
		m_edit1=rsSt.m_edit1;
 		m_edit2=rsSt.m_edit2;
		m_edit3=rsSt.m_edit3;
		m_edit4=rsSt.m_edit4;
  		m_bakserver1=rsSt.m_bakserver1;
 		m_bakserver2=rsSt.m_bakserver2;
		m_bakserver3=rsSt.m_bakserver3;
		m_bakserver4=rsSt.m_bakserver4; 
 		m_bakserver5=rsSt.m_bakserver5;
	}
	rsSt.Close(); 
	}
	g_bakinfo="资料未备份";
	g_bakphoto="照片未备份";
	WriteLogin("开始备份资料");
	if(!m_bakserver5.IsEmpty())
	{
		CString bakpath,localname;
 
	localname=g_localname;

#ifdef CHILD_VERSION
	if(localname.CompareNoCase (m_bakserver5)==0 || CompareIP(localname, m_bakserver5)==0)
		bakpath=GetPathFromNetShareName("数据备份(儿童管理软件)$");
	else
		bakpath="\\\\"+m_bakserver5+"\\数据备份(儿童管理软件)$";
#else
	if(localname.CompareNoCase (m_bakserver5)==0 || CompareIP(localname, m_bakserver5)==0)
		bakpath=GetPathFromNetShareName("数据备份(管理软件)$");
	else
		bakpath="\\\\"+m_bakserver5+"\\数据备份(管理软件)$";
#endif
	if(::CheckFolderFileExist (bakpath))
		BakData(bakpath, 1, 1);
	}
	WriteLogin("资料备份完成");

	BOOL bcheck1=atoi(m_check1);
	BOOL bcheck2=atoi(m_check2);
	BOOL bcheck3=atoi(m_check3);
	BOOL bcheck4=atoi(m_check4);
 	if( !(bcheck1 || bcheck2 || bcheck3 || bcheck4) )
	{
		return;
	} 
	int edit1=atoi(m_edit1);
	int edit2=atoi(m_edit2);
	int edit3=atoi(m_edit3);
	int edit4=atoi(m_edit4);

	//path
	CStringArray patharray;
	{
	char server[50];
	DWORD leng=50;
	::GetComputerName (server, &leng);	
	CString spathserver=server;
	CString g_path1;
	CString g_path2;
	CString g_path3;
	CString g_path4;
	g_path1=GetPathFromNetShareName("客户原片(管理软件)$");
	g_path2=GetPathFromNetShareName("修好的片(管理软件)$");
	g_path3=GetPathFromNetShareName("设计好的片(管理软件)$");
	g_path4=GetPathFromNetShareName("精修好的片(管理软件)$");
 
		patharray.Add(g_path1) ;
		patharray.Add(g_path2) ;
		patharray.Add(g_path4) ;
		patharray.Add(g_path3) ;
	/*	patharray.Add("\\\\"+spathserver+"\\客户原片(管理软件)$") ;
		patharray.Add("\\\\"+spathserver+"\\修好的片(管理软件)$") ;
		patharray.Add("\\\\"+spathserver+"\\精修好的片(管理软件)$") ;
		patharray.Add("\\\\"+spathserver+"\\设计好的片(管理软件)$") ;*/
 
	}
	if(patharray.GetSize ()==0)return;
 

	CArray<CDatabase*,CDatabase*>dbarray2;
	dbarray2.Copy(dbarray);
	dbarray2.InsertAt(0, &g_db);

	WriteLogin("开始删除取件后照片");
	for(int n=0; n<min(2,dbarray2.GetSize ()); n++)
	{
		g_curdb=dbarray2.ElementAt (n);
	DWORD ii=0;
    CArray<CStringArray, CStringArray>g_List1array;
	{
	CString filter="status3='OK' and time5 is not null and time5<>''";
 	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from dindan";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	if(count==0)continue;
	g_List1array.SetSize(count , 1 );
	CRstDindanForm rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.id) ;
		g_List1array.ElementAt (ii).Add(rsSt.time5) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();
	g_List1array.SetSize(ii , 1 );

	CString time5,id;
	CTime curtm=CTime::GetCurrentTime ();
	CString strtime;
	for(int i=0; i<g_List1array.GetSize (); i++)
	{
		id=g_List1array.ElementAt (i).ElementAt (0);
		time5=g_List1array.ElementAt (i).ElementAt (1);
		if(bcheck1)//原片
		{
			CTimeSpan sp(edit1*30, 0, 0, 0);
			CTime tm=curtm-sp;
			strtime=tm.Format ("%Y-%m-%d");
			if(strtime>time5)
			{
				DelPhoto1(patharray.ElementAt (0),g_List1array.ElementAt (i).ElementAt (0));
			//	DelPhoto1(patharray2.ElementAt (0),g_List1array.ElementAt (i).ElementAt (0));
			}
		}
		if(bcheck2)
		{
			CTimeSpan sp(edit2*30, 0, 0, 0);
			CTime tm=curtm-sp;
			strtime=tm.Format ("%Y-%m-%d");
			if(strtime>time5)
			{
				DelPhoto1(patharray.ElementAt (1),g_List1array.ElementAt (i).ElementAt (0));
			//	DelPhoto1(patharray2.ElementAt (2),g_List1array.ElementAt (i).ElementAt (0));
			}
		}
		if(bcheck3)
		{
			CTimeSpan sp(edit3*30, 0, 0, 0);
			CTime tm=curtm-sp;
			strtime=tm.Format ("%Y-%m-%d");
			if(strtime>time5)
			{
				DelPhoto1(patharray.ElementAt (2),g_List1array.ElementAt (i).ElementAt (0));
			//	DelPhoto1(patharray2.ElementAt (2),g_List1array.ElementAt (i).ElementAt (0));
			}
		}
		if(bcheck4)
		{
			CTimeSpan sp(edit4*30, 0, 0, 0);
			CTime tm=curtm-sp;
			strtime=tm.Format ("%Y-%m-%d");
			if(strtime>time5)
			{
				DelPhoto1(patharray.ElementAt (3),g_List1array.ElementAt (i).ElementAt (0));
			}
		}
	}
	}
	}
g_curdb=&g_db;
#ifdef ENTERPRISE_VERSION
	WriteLogin("本店查完,开始检查分店");
	CString g_domain;
	for( n=0; n<g_branchdbarray.GetSize(); n++)
	{
		g_curdb=g_branchdbarray.ElementAt (n);	
		if(g_curdb==NULL)continue;
		if(g_branchdomainarray.ElementAt (n)=="")continue;
		g_domain="\\"+g_branchdomainarray.ElementAt (n);

	DWORD ii=0;
    CArray<CStringArray, CStringArray>g_List1array;
	{
	CString filter="status3='OK' and time5 is not null and time5<>''";
 	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from dindan";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	if(count==0)continue;
	g_List1array.SetSize(count , 1 );
	CRstDindanForm rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    ii=0;
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.id) ;
		g_List1array.ElementAt (ii).Add(rsSt.time5) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();
	g_List1array.SetSize(ii , 1 );

	CString time5,id;
	CTime curtm=CTime::GetCurrentTime ();
	CString strtime;
	for(int i=0; i<g_List1array.GetSize (); i++)
	{
		id=g_List1array.ElementAt (i).ElementAt (0);
		time5=g_List1array.ElementAt (i).ElementAt (1);
		if(bcheck1)//原片
		{
			CTimeSpan sp(edit1*30, 0, 0, 0);
			CTime tm=curtm-sp;
			strtime=tm.Format ("%Y-%m-%d");
			if(strtime>time5)
			{
				DelPhoto1(patharray.ElementAt (0)+g_domain,g_List1array.ElementAt (i).ElementAt (0));
			}
		}
		if(bcheck2)
		{
			CTimeSpan sp(edit2*30, 0, 0, 0);
			CTime tm=curtm-sp;
			strtime=tm.Format ("%Y-%m-%d");
			if(strtime>time5)
			{
				DelPhoto1(patharray.ElementAt (1)+g_domain,g_List1array.ElementAt (i).ElementAt (0));
			//	DelPhoto1(patharray2.ElementAt (2),g_List1array.ElementAt (i).ElementAt (0));
			}
		}
		if(bcheck3)
		{
			CTimeSpan sp(edit3*30, 0, 0, 0);
			CTime tm=curtm-sp;
			strtime=tm.Format ("%Y-%m-%d");
			if(strtime>time5)
			{
				DelPhoto1(patharray.ElementAt (2)+g_domain,g_List1array.ElementAt (i).ElementAt (0));
			//	DelPhoto1(patharray2.ElementAt (2),g_List1array.ElementAt (i).ElementAt (0));
			}
		}
		if(bcheck4)
		{
			CTimeSpan sp(edit4*30, 0, 0, 0);
			CTime tm=curtm-sp;
			strtime=tm.Format ("%Y-%m-%d");
			if(strtime>time5)
			{
				DelPhoto1(patharray.ElementAt (3)+g_domain,g_List1array.ElementAt (i).ElementAt (0));
			}
		}
	}
	}
	}
	g_curdb=&g_db;
#endif
    WriteLogin("检查删除照片完成");
	}
	catch(...)
	{
		WriteLogin("出错在函数AutoDelPhoto中");
	}
	g_curdb=&g_db;
}
void DeleteDirectory(CString strDir)
{
	try
	{
  //   首先删除文件及子文件夹   
  CFileFind   ff;   
  BOOL   bFound   =   ff.FindFile(strDir+"\\*",   0);   
  while(bFound)   
  {   
  bFound   =   ff.FindNextFile();   
  if(ff.GetFileName()=="."||ff.GetFileName()=="..")   
  continue;   
  //   去掉文件(夹)只读等属性   
  SetFileAttributes(ff.GetFilePath(),   FILE_ATTRIBUTE_NORMAL);   
  if(ff.IsDirectory())   {   //   递归删除子文件夹   
  DeleteDirectory(ff.GetFilePath());   
  RemoveDirectory(ff.GetFilePath());   
  }   
  else   {   
  DeleteFile(ff.GetFilePath());   //   删除文件   
  }   
  }   
  ff.Close();   
  //   然后删除该文件夹   
  RemoveDirectory(strDir);
	}
	catch(...)
	{
		WriteLogin("出错在函数deldir中");
	}
//	int SHFileOperation( LPSHFILEOPSTRUCT   lpFileOp   );   
}

void CDBServerDlg::DelPhoto1(CString path, CString id)
{
	if(::CheckFolderFileExist (path+"\\"+id))
	{
		DeleteDirectory(path+"\\"+id);
	}
}
extern void ConvertToPrice(CString &str);
int GetLengthEx(CString str)
{
	wchar_t   wstr[500];
	int   k   =   MultiByteToWideChar(CP_ACP,   MB_PRECOMPOSED,   str,   strlen(str),   wstr,   500); 
	return k;

/*	try
	{
	int leng=0;
	TBYTE ucHigh, ucLow;
    for (int i=0; i<str.GetLength(); i++)
    {
        if ( (TBYTE)str[i] < 0x80 )
		{
			leng++;
            continue;
		}

        ucHigh = (TBYTE)str[i];
		if(i+1==str.GetLength())
		{
			leng++;
            break;
		}
        ucLow  = (TBYTE)str[i+1];
        if ( ucHigh < 0xa1 || ucLow < 0xa1)
		{
			leng++;
            continue;
		}
		leng++;
        i++;
    }
	return leng;
	}
	catch(...)
	{
		WriteLogin("出错");
	}*/
}

void CDBServerDlg::BakPhoto()
{
	try
	{
	g_curdb=&g_db;
	CString	m_bak1,m_bak2,m_bak3,m_bak4,m_bak6,m_baktime;
	CString	m_bakserver1,m_bakserver2,m_bakserver3,m_bakserver4;
	CString	msgcheck4,msgtime,msgphones,msgphones2,msgcompanyname;
	CString balance,msgaccount;
	{
    MyLock lock("dbaccessxiao");
	CRstversion rsSt;
	rsSt.Open();
	if(!rsSt.IsEOF())
	{
 		m_bak1=rsSt.m_bak1;
 		m_bak2=rsSt.m_bak2;
		m_bak3=rsSt.m_bak3;
		m_bak4=rsSt.m_bak4; 
  		m_bakserver1=rsSt.m_bakserver1;
 		m_bakserver2=rsSt.m_bakserver2;
		m_bakserver3=rsSt.m_bakserver3;
		m_bakserver4=rsSt.m_bakserver4; 
 		m_bak6=rsSt.m_bak6;
 		m_baktime=rsSt.m_baktime; 
 		msgcheck4=rsSt.msgcheck4; 
		msgtime=rsSt.msgtime;			
		msgphones=rsSt.msgphones;	
 		msgphones2=rsSt.msgphones2;	
		msgcompanyname=rsSt.msgcompanyname;	
		balance=rsSt.msgbalance;
		msgaccount=rsSt.msgaccount;	
	}
	rsSt.Close(); 
  


	}
/////////////检测发短信回财务
	if(msgphones2.IsEmpty ()==0)
	{
	MyLock lock("dbaccessxiao");
	CStringArray array,timearray;
	
	CString timestamp;
	timestamp=CTime::GetCurrentTime ().Format ("%Y-%m-%d");
	timestamp+="%";
	CRecordset myset(g_curdb);
	CString	sql="select * from sendregreceive where [timestamp] like '"+timestamp+"' and [content]='001' and [status]='OK'";
	myset.Open (CRecordset::forwardOnly, sql);
	CString phones;
	while(!myset.IsEOF())
	{
		myset.GetFieldValue ("phones", phones);
		myset.GetFieldValue ("timestamp", timestamp);
		if(msgphones2.Find (phones)!=-1)
		{
		array.Add(phones ) ;
		timearray.Add (timestamp );
		}
		myset.MoveNext();
	}
	myset.Close();
	if(array.GetSize ())
	{
	CString sql;
	for(int i=0; i<array.GetSize (); i++)
	{
	   sql="update sendregreceive set [status]='' where [timestamp]='"+timearray.ElementAt (i)+"'";
       MyExecuteSQL (&g_db, sql);
	}
				CArray<CStringArray, CStringArray>List11array;
				CArray<CStringArray, CStringArray>List2array;
				CArray<CStringArray, CStringArray>List3array;
				
 
				CArray<CStringArray, CStringArray>other2salearray;			
				CString strdate=CTime::GetCurrentTime ().Format ("%Y-%m-%d");

				
	CString filter="[dat]='"+strdate+"'";
	 filter="[dat]='"+strdate+"' and ([sale2type] is null or [sale2type]='')";
				
 
	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from singleincome";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	List2array.SetSize(count , 1 );
	CRstIncomeInput rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    int ii=0;
	while(!rsSt.IsEOF())
	{
    	List2array.ElementAt (ii).RemoveAll ();
		List2array.ElementAt (ii).Add(rsSt.id) ;
		List2array.ElementAt (ii).Add(rsSt.name) ;
		List2array.ElementAt (ii).Add(rsSt.money) ;
		List2array.ElementAt (ii).Add(rsSt.date) ;
		List2array.ElementAt (ii).Add(rsSt.renyuan1) ;
		List2array.ElementAt (ii).Add(rsSt.renyuan2) ;
		List2array.ElementAt (ii).Add(rsSt.renyuan3) ;
		List2array.ElementAt (ii).Add(rsSt.bz) ;
		List2array.ElementAt (ii).Add(rsSt.sale2type) ;
		ii++;
		rsSt.MoveNext();if(List2array.GetSize ()<=ii)break;
	}
	rsSt.Close();List2array.SetSize(ii , 1 );
	}

	filter="[dat]='"+strdate+"'";
	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from gudingfeiyong";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	List3array.SetSize(count , 1 );
	CRstPayOutInput rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    int ii=0;
	while(!rsSt.IsEOF())
	{
    	List3array.ElementAt (ii).RemoveAll ();
		List3array.ElementAt (ii).Add(rsSt.id) ;
		List3array.ElementAt (ii).Add(rsSt.name) ;
		List3array.ElementAt (ii).Add(rsSt.money) ;
		List3array.ElementAt (ii).Add(rsSt.date) ;
		List3array.ElementAt (ii).Add(rsSt.renyuan1) ;
		List3array.ElementAt (ii).Add(rsSt.renyuan2) ;
		List3array.ElementAt (ii).Add(rsSt.bz) ;
		ii++;
		rsSt.MoveNext();if(List3array.GetSize ()<=ii)break;
	}
	rsSt.Close();List3array.SetSize(ii , 1 );
	}
	
	filter="[date]='"+strdate+"'";
	{
 
 		{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from dindanbukuan";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	List11array.SetSize(count , 1 );
	CRstBuKuan rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    int    ii=0;
	while(!rsSt.IsEOF())
	{
    	List11array.ElementAt (ii).RemoveAll ();
		List11array.ElementAt (ii).Add(rsSt.m_id) ;
		List11array.ElementAt (ii).Add(rsSt.m_ren) ;
		List11array.ElementAt (ii).Add(rsSt.m_money) ;
		List11array.ElementAt (ii).Add(rsSt.m_bz) ;
		List11array.ElementAt (ii).Add(rsSt.m_kind) ;
		List11array.ElementAt (ii).Add(rsSt.m_date) ;
		ii++;
		rsSt.MoveNext();if(List11array.GetSize ()<=ii)break;
	}
	rsSt.Close();List11array.SetSize(ii , 1 );
		}
 
	}
	filter="[date]='"+strdate+"'";
 	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from singleincomemoneyview";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	other2salearray.SetSize(count , 1 );
	CRstsingleincomemoneyview rsSt;	rsSt.m_pDatabase=g_curdb;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    int ii=0;
	while(!rsSt.IsEOF())
	{
    	other2salearray.ElementAt (ii).RemoveAll ();
		other2salearray.ElementAt (ii).Add(rsSt.name) ;
		other2salearray.ElementAt (ii).Add(rsSt.renyuan1) ;
		other2salearray.ElementAt (ii).Add(rsSt.renyuan3) ;
		other2salearray.ElementAt (ii).Add(rsSt.sale2type) ;
		other2salearray.ElementAt (ii).Add(rsSt.money) ;
		other2salearray.ElementAt (ii).Add(rsSt.date) ;
		other2salearray.ElementAt (ii).Add(rsSt.clerk) ;
		other2salearray.ElementAt (ii).Add(rsSt.paytype) ;	
		other2salearray.ElementAt (ii).Add(rsSt.autoid) ;
		other2salearray.ElementAt (ii).Add(rsSt.financecheck) ;
		ii++;
		rsSt.MoveNext();if(other2salearray.GetSize ()<=ii)break;
	}
	rsSt.Close();other2salearray.SetSize(ii , 1 );
	}

	CString str;
	int pos=0;
	int dindanshu=0;
	float income=0;
	float incomedd=0;
	float incomebk=0;
	float incomehq=0;
	float incomeqt=0;
	float payout=0;

    for( i=0; i<List11array.GetSize (); i++)
	{
		str=List11array.ElementAt (i).ElementAt (2);
		income+=atof(str);
//		income2+=atof(str);
		if(List11array.ElementAt (i).ElementAt (3)=="预约收款")
		{
			incomedd+=atof(str);
			dindanshu++;
		}
		else if(List11array.ElementAt (i).ElementAt (3)=="预约补款")
		{
			incomebk+=atof(str);
		}
		else 
		{
			incomehq+=atof(str);
		}
		pos++;
	}
	for( i=0; i<List2array.GetSize (); i++)
	{
		str=List2array.ElementAt (i).ElementAt (2);
		income+=atof(str);
	/*	if(List2array.ElementAt (i).ElementAt (8)!="")
		{
			income2+=atof(str);
		}*/

		if(List2array.ElementAt (i).ElementAt (8)=="")
		{
			incomeqt+=atof(str);
		}
		pos++;
	}
	for( i=0; i<List3array.GetSize (); i++)
	{
		str=List3array.ElementAt (i).ElementAt (2);
		payout+=atof(str);
		pos++;
	} 
	for( i=0; i<other2salearray.GetSize (); i++)
	{
	 
		str=other2salearray.ElementAt (i).ElementAt (4);
 
		income+=atof(str);
	 	incomehq+=atof(str);
		pos++;
	} 

	CTime tm=CTime::GetCurrentTime ();
	CString content=msgcompanyname+tm.Format ("%Y-%m-%d");
	content+="财报:";


	str.Format ("%d", (int)income);
	::ConvertToPrice (str);
	content+="收:"+str;

	str.Format ("%d", (int)incomedd);
	::ConvertToPrice (str);
	content+="定:"+str;

	str.Format ("%d", (int)incomebk);
	::ConvertToPrice (str);
	content+="补:"+str;

	str.Format ("%d", (int)incomehq);
	::ConvertToPrice (str);
	content+="后:"+str;

	str.Format ("%d", (int)incomeqt);
	::ConvertToPrice (str);
	content+="其它:"+str;


	str.Format ("%d", (int)payout);
	::ConvertToPrice (str);
	content+="支出:"+str;

	str.Format ("%d", (int)(income-payout));
	::ConvertToPrice (str);
	content+="净收:"+str;

	str.Format ("%d", dindanshu);
	content+="定单:"+str;

	if(msgaccount!="")
	{
	if(atoi(balance)<200)
	{
		content+="您的余额小于两百条，请及时充值。联系电话4006067068";
	}
	else if(atoi(balance)<500)
	{
		content+="您的余额小于五百条，请及时充值。联系电话4006067068";
	}
	else if(atoi(balance)<800)
	{
		content+="您的余额小于八百条，请及时充值。联系电话4006067068";
	}
	else if(atoi(balance)<1000)
	{
		content+="您的余额小于一千条，请及时充值。联系电话4006067068";
	}
	}

	int count=GetLengthEx(content)/MSG_LENGTH;
	if(GetLengthEx(content)%MSG_LENGTH)
		count++;

	int phonenum=0;
	phonenum=1;
	count*=phonenum;
	CString scount;
	scount.Format ("%d", count);
	CString timestamp=tm.Format ("%Y%m%d%H%M%S");
	for( i=0; i<1; i++)
	{
 	sql="insert into sendreg([phones],[content],[timestamp],[msgcount],[status],[issended],[isautosend],[ren]) values\
('"+array.ElementAt (i)+"','"+content+"','"+timestamp+"','"+scount+"','0','0','0','系统自动发送')";
    MyExecuteSQL (&g_db, sql); 
	}
	}
	}
/////////////
 	if(atoi(msgcheck4) && msgphones!="")
	{//发老板短信
	    if(atoi(msgtime)<=CTime::GetCurrentTime ().GetHour ())
		{
			MyLock lock("dbaccessxiao");
			CString timestamp;
			timestamp=CTime::GetCurrentTime ().Format ("%Y%m%d");
			timestamp+="%";
			CRecordset myset(g_curdb);
			CString	sql="select count(*) as cot from sendreg where [timestamp] like '"+timestamp+"' and [phones]='"+msgphones+"' and [isautosend]='3'";
			myset.Open (CRecordset::forwardOnly, sql);
			myset.GetFieldValue ("cot", sql);
			myset.Close();
			int count=atol(sql);
			if(count==0)
			{
				CArray<CStringArray, CStringArray>List11array;
				CArray<CStringArray, CStringArray>List2array;
				CArray<CStringArray, CStringArray>List3array;
				CArray<CStringArray, CStringArray>other2salearray;			
				CString strdate=CTime::GetCurrentTime ().Format ("%Y-%m-%d");

				
	CString filter="[dat]='"+strdate+"'";
	 filter="[dat]='"+strdate+"' and ([sale2type] is null or [sale2type]='')";
 
 
	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from singleincome";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
 
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	List2array.SetSize(count , 1 );
	CRstIncomeInput rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
 
    int ii=0;
	while(!rsSt.IsEOF())
	{
    	List2array.ElementAt (ii).RemoveAll ();
		List2array.ElementAt (ii).Add(rsSt.id) ;
		List2array.ElementAt (ii).Add(rsSt.name) ;
		List2array.ElementAt (ii).Add(rsSt.money) ;
		List2array.ElementAt (ii).Add(rsSt.date) ;
		List2array.ElementAt (ii).Add(rsSt.renyuan1) ;
		List2array.ElementAt (ii).Add(rsSt.renyuan2) ;
		List2array.ElementAt (ii).Add(rsSt.renyuan3) ;
		List2array.ElementAt (ii).Add(rsSt.bz) ;
		List2array.ElementAt (ii).Add(rsSt.sale2type) ;
		ii++;
		rsSt.MoveNext();if(List2array.GetSize ()<=ii)break;
	}
	rsSt.Close();List2array.SetSize(ii , 1 );
 
	}
 


	filter="[dat]='"+strdate+"'";
	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from gudingfeiyong";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	List3array.SetSize(count , 1 );
	CRstPayOutInput rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    int ii=0;
	while(!rsSt.IsEOF())
	{
    	List3array.ElementAt (ii).RemoveAll ();
		List3array.ElementAt (ii).Add(rsSt.id) ;
		List3array.ElementAt (ii).Add(rsSt.name) ;
		List3array.ElementAt (ii).Add(rsSt.money) ;
		List3array.ElementAt (ii).Add(rsSt.date) ;
		List3array.ElementAt (ii).Add(rsSt.renyuan1) ;
		List3array.ElementAt (ii).Add(rsSt.renyuan2) ;
		List3array.ElementAt (ii).Add(rsSt.bz) ;
		ii++;
		rsSt.MoveNext();if(List3array.GetSize ()<=ii)break;
	}
	rsSt.Close();List3array.SetSize(ii , 1 );
	}
 
	
	filter="[date]='"+strdate+"'";
	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from dindanbukuan";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	List11array.SetSize(count , 1 );
	CRstBuKuan rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    int    ii=0;
	while(!rsSt.IsEOF())
	{
    	List11array.ElementAt (ii).RemoveAll ();
		List11array.ElementAt (ii).Add(rsSt.m_id) ;
		List11array.ElementAt (ii).Add(rsSt.m_ren) ;
		List11array.ElementAt (ii).Add(rsSt.m_money) ;
		List11array.ElementAt (ii).Add(rsSt.m_bz) ;
		List11array.ElementAt (ii).Add(rsSt.m_kind) ;
		List11array.ElementAt (ii).Add(rsSt.m_date) ;
		ii++;
		rsSt.MoveNext();if(List11array.GetSize ()<=ii)break;
	}
	rsSt.Close();List11array.SetSize(ii , 1 );
	}
	
	filter="[date]='"+strdate+"'";
 	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from singleincomemoneyview";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	other2salearray.SetSize(count , 1 );
	CRstsingleincomemoneyview rsSt;	rsSt.m_pDatabase=g_curdb;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    int ii=0;
	while(!rsSt.IsEOF())
	{
    	other2salearray.ElementAt (ii).RemoveAll ();
		other2salearray.ElementAt (ii).Add(rsSt.name) ;
		other2salearray.ElementAt (ii).Add(rsSt.renyuan1) ;
		other2salearray.ElementAt (ii).Add(rsSt.renyuan3) ;
		other2salearray.ElementAt (ii).Add(rsSt.sale2type) ;
		other2salearray.ElementAt (ii).Add(rsSt.money) ;
		other2salearray.ElementAt (ii).Add(rsSt.date) ;
		other2salearray.ElementAt (ii).Add(rsSt.clerk) ;
		other2salearray.ElementAt (ii).Add(rsSt.paytype) ;	
		other2salearray.ElementAt (ii).Add(rsSt.autoid) ;
		other2salearray.ElementAt (ii).Add(rsSt.financecheck) ;
		ii++;
		rsSt.MoveNext();if(other2salearray.GetSize ()<=ii)break;
	}
	rsSt.Close();other2salearray.SetSize(ii , 1 );
	}

	CString str;
	int pos=0;
	int dindanshu=0;
	float income=0;
	float incomedd=0;
	float incomebk=0;
	float incomehq=0;
	float incomeqt=0;
	float payout=0;

    for(int i=0; i<List11array.GetSize (); i++)
	{
		str=List11array.ElementAt (i).ElementAt (2);
		income+=atof(str);
//		income2+=atof(str);
		if(List11array.ElementAt (i).ElementAt (3)=="预约收款")
		{
			incomedd+=atof(str);
			dindanshu++;
		}
		else if(List11array.ElementAt (i).ElementAt (3)=="预约补款")
		{
			incomebk+=atof(str);
		}
		else 
		{
			incomehq+=atof(str);
		}
		pos++;
	}
	 
	for( i=0; i<List2array.GetSize (); i++)
	{
		str=List2array.ElementAt (i).ElementAt (2);
		income+=atof(str);
	/*	if(List2array.ElementAt (i).ElementAt (8)!="")
		{
			income2+=atof(str);
		}*/

		if(List2array.ElementAt (i).ElementAt (8)=="")
		{
			incomeqt+=atof(str);
		}
		pos++;
	}
 
	for( i=0; i<List3array.GetSize (); i++)
	{
		str=List3array.ElementAt (i).ElementAt (2);
		payout+=atof(str);
		pos++;
	}
	for( i=0; i<other2salearray.GetSize (); i++)
	{
		str=other2salearray.ElementAt (i).ElementAt (4);
		income+=atof(str);
	 	incomehq+=atof(str);
		pos++;
	} 

	CTime tm=CTime::GetCurrentTime ();
	CString content=msgcompanyname+tm.Format ("%Y-%m-%d");
	content+="财报:";


	str.Format ("%d", (int)income);
	::ConvertToPrice (str);
	content+="收:"+str;

	str.Format ("%d", (int)incomedd);
	::ConvertToPrice (str);
	content+="定:"+str;

	str.Format ("%d", (int)incomebk);
	::ConvertToPrice (str);
	content+="补:"+str;

	str.Format ("%d", (int)incomehq);
	::ConvertToPrice (str);
	content+="后:"+str;

	str.Format ("%d", (int)incomeqt);
	::ConvertToPrice (str);
	content+="其它:"+str;


	str.Format ("%d", (int)payout);
	::ConvertToPrice (str);
	content+="支出:"+str;

	str.Format ("%d", (int)(income-payout));
	::ConvertToPrice (str);
	content+="净收:"+str;

	str.Format ("%d", dindanshu);
	content+="定单:"+str;

	if(msgaccount!="")
	{
	if(atoi(balance)<200)
	{
		content+="您的余额小于两百条，请及时充值。联系电话4006067068";
	}
	else if(atoi(balance)<500)
	{
		content+="您的余额小于五百条，请及时充值。联系电话4006067068";
	}
	else if(atoi(balance)<800)
	{
		content+="您的余额小于八百条，请及时充值。联系电话4006067068";
	}
	else if(atoi(balance)<1000)
	{
		content+="您的余额小于一千条，请及时充值。联系电话4006067068";
	}
	}
 

	int count=GetLengthEx(content)/MSG_LENGTH;
	if(GetLengthEx(content)%MSG_LENGTH)
		count++;

	int phonenum=0;
	str=msgphones;
 	  pos=str.Find (",");
	if(pos!=-1)
	{
		while(pos!=-1)
		{
			phonenum++;
			str=str.Right (str.GetLength ()-pos-1);
			pos=str.Find (",");
		}
		phonenum++;
	}
	else
		phonenum=1;
	count*=phonenum;

	CString scount;
	scount.Format ("%d", count);
	timestamp=tm.Format ("%Y%m%d%H%M%S");
	sql="insert into sendreg([phones],[content],[timestamp],[msgcount],[status],[issended],[isautosend],[ren]) values\
('"+msgphones+"','"+content+"','"+timestamp+"','"+scount+"','0','0','3','系统自动发送')";
    MyExecuteSQL (&g_db, sql);
			}
		}
	}

	BOOL bcheck1=atoi(m_bak1);
	BOOL bcheck2=atoi(m_bak2);
	BOOL bcheck3=atoi(m_bak3);
	BOOL bcheck4=atoi(m_bak4);
  
 
	int hour;
	hour=CTime::GetCurrentTime ().GetHour ();
 
 	if(atoi(m_baktime)<=hour)
	{
	CStdioFile fp;
	if(fp.Open (g_mainpath+"\\log.txt", CFile::modeRead))
	{
		CString date;
		fp.ReadString (date);
		date.TrimRight ("\r\n");
		if(date==CTime::GetCurrentTime ().Format ("%Y-%m-%d"))	
		{
			fp.Close ();
			return;
		}
		fp.Close ();
	}	
	if(g_bConvertHisAll)
	{	
		WriteLogin("转历史数据中, 备份退出");
		return;
	}
	g_bakdate=CTime::GetCurrentTime ().Format ("%Y-%m-%d");
	KillTimer(4);
	WriteLogin("备份开始...");
 

 	AutoDelPhoto();
    LoadThumbImages2();
	}
	}
	catch(...)
	{
	    	WriteLogin("出错在函数bakphoto中");
	}
}

void CDBServerDlg::ShutDown()
{
	try
	{
	 g_curdb=&g_db;
	CString	m_bak6;
	{
 	CRecordset myset(g_curdb);
	CString	sql="select * from [version]";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("bak6", m_bak6);
	myset.Close();
	}

	OnServerStop();


	g_db.Close ();
	for(int i=0;i<dbarray.GetSize (); i++)
	{
		dbarray.ElementAt (i)->Close ();
		delete dbarray.ElementAt (i);
	}
	ReleaseBranchDB();
/*	if(!m_bakserver5.IsEmpty())
	{
#ifdef CHILD_VERSION
		if(::CheckFolderFileExist ("\\\\"+m_bakserver5+"\\数据备份(儿童管理软件)$"))
			BakData("\\\\"+m_bakserver5+"\\数据备份(儿童管理软件)$", 1, 1);
#else
		if(::CheckFolderFileExist ("\\\\"+m_bakserver5+"\\数据备份(管理软件)$"))
			BakData("\\\\"+m_bakserver5+"\\数据备份(管理软件)$", 1, 1);
#endif
	}*/
	WriteLogin("备份完成");
	while(m_bRunning)
	{
		::Sleep (1000);
	}
////////////////
	g_tisks=::GetTickCount ()-g_tisks;
	CString str;
	str.Format ("耗时:%d分钟", g_tisks/60000);

	CStdioFile fp;
	fp.Open (g_mainpath+"\\log.txt", CFile::modeCreate|CFile::modeWrite);
	CTime tm=CTime::GetCurrentTime ();
	if(0)//tm.GetHour ()<5)
	{
		CTimeSpan sp(1, 0, 0, 0);
		tm-=sp;
	    fp.WriteString (tm.Format ("%Y-%m-%d"));
		fp.WriteString ("\r\n");
		fp.WriteString (CTime::GetCurrentTime ().Format ("%Y-%m-%d %H:%M:%S"));
		fp.WriteString (str);
	}
	else
	{
	    fp.WriteString (g_bakdate);
		fp.WriteString ("\r\n");
		fp.WriteString (tm.Format ("%Y-%m-%d %H:%M:%S"));
		fp.WriteString (str);
	}
	fp.WriteString ("\r\n");
	fp.WriteString (g_bakinfo);
	fp.WriteString ("\r\n");
	fp.WriteString (g_bakphoto);
	fp.Close ();


//	OnButton3();

	if(atoi(m_bak6))
	{
	// TODO: Add your command handler code here
	TerminateThread();
	TerminateThread2();
 
	DWORD id=FindAppProcessID("AutoRun.exe");
	if(id!=-1)
	{
		HANDLE ProcessHandle=OpenProcess(PROCESS_ALL_ACCESS,FALSE,id);
		if(ProcessHandle)TerminateProcess(ProcessHandle,0);
	}

	m_TrayIcon.RemoveIcon();
    if(g_pSkinData)delete []g_pSkinData;g_pSkinData=NULL;

	MyExitWindows();
	}
	else//重启
	{
	TerminateThread();
	TerminateThread2();
 
	m_TrayIcon.RemoveIcon();
    if(g_pSkinData)delete []g_pSkinData;g_pSkinData=NULL;
	WriteLogin("备份完成,服务器重启");
	CDialog::OnCancel ();
	}
	}
	catch(...)
	{
		WriteLogin("出错在函数shutdown中");
	}
}

void CDBServerDlg::MyExitWindows()
{
	try
	{
  UINT   t=EWX_SHUTDOWN|EWX_FORCE;   
  OSVERSIONINFO   osv;     //定义一个操作系统信息的结构体   
  osv.dwOSVersionInfoSize=sizeof   OSVERSIONINFO;   
  GetVersionEx(&osv);       //查询当前操作系统   
  if(osv.dwPlatformId==VER_PLATFORM_WIN32_NT)     //判断是否是2000/NT   
  {   
    //下面为向操作系统获取权限操作   
  HANDLE   hProcess,hToken;   
  TOKEN_PRIVILEGES   Privileges;   
  LUID   luid;   
  hProcess=GetCurrentProcess();   
  //下面为打开当前进程对话   
  OpenProcessToken(hProcess,TOKEN_ADJUST_PRIVILEGES,&hToken);   
  Privileges.PrivilegeCount=1;   
  LookupPrivilegeValue(NULL,SE_SHUTDOWN_NAME,&luid);   
  Privileges.Privileges[0].Luid=luid;   
  Privileges.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;   
  AdjustTokenPrivileges(hToken,FALSE,&Privileges,NULL,NULL,NULL);   
  ExitWindowsEx(t,0);   
  }   
  else
  {
  ExitWindowsEx(t,0);//调用ExitWindowsEx关闭机器。     
  PostQuitMessage(0);   
  }
	}
	catch(...)
	{
		WriteLogin("出错在函数exitwindows中");
	}
}

void CDBServerDlg::OnAutorun() 
{
	// TODO: Add your command handler code here
	g_bAutoRun=!g_bAutoRun;
    CString version = _T ("Version 1.0");
	AfxGetApp()->WriteProfileInt (version, "brun", g_bAutoRun);	
	TCHAR szKey[MAX_PATH];
	HKEY hKey=0; 
	DWORD disp=0;
	lstrcpy(szKey,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run"); 
	if(g_bAutoRun)
	{
		int lResult=RegCreateKeyEx(HKEY_LOCAL_MACHINE,szKey,0,NULL,REG_OPTION_VOLATILE, KEY_ALL_ACCESS,NULL,&hKey,&disp); 
		if(lResult==ERROR_SUCCESS)
		{ 
			TCHAR szDir[MAX_PATH];
			::GetModuleFileName (NULL, szDir, MAX_PATH);
			lResult=RegSetValueEx(hKey,"YLGLDBSERVER",0,REG_SZ,(const unsigned char*)szDir,lstrlen(szDir)); 
			RegCloseKey(hKey); 
		}
	}
	else
	{
		int lResult=RegCreateKeyEx(HKEY_LOCAL_MACHINE,szKey,0,NULL,REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,NULL,&hKey,&disp); 
		if(lResult==ERROR_SUCCESS)
		{
			RegDeleteValue(hKey,"YLGLDBSERVER"); 
			RegDeleteKey (hKey,"YLGLDBSERVER"); 
			RegCloseKey(hKey); 
		}
	}	
}

void CDBServerDlg::GetFileDate()
{
	CStringArray filesarray;
	filesarray.Add ("AutoUpdate.exe");
	filesarray.Add ("skin\\1.lia");
	filesarray.Add ("skin\\2.lia");
	filesarray.Add ("skin\\3.lia");
	filesarray.Add ("skin\\4.lia");
	filesarray.Add ("skin\\10.lia");
	filesarray.Add ("skin\\logo.jpg");
	filesarray.Add ("skin\\标题-选片.jpg");
	filesarray.Add ("skin\\标题-看设计.jpg");
	filesarray.Add ("图片\\欢迎.jpg");
	filesarray.Add ("图片\\连接.jpg");
	filesarray.Add ("图片\\标题.jpg");
	filesarray.Add ("图片\\背景.jpg");
	for(int i=0; i<filesarray.GetSize (); i++)
	{
		g_filedatearray.Add (GetModifyTime(g_mainpath+"\\系统文件\\"+filesarray.ElementAt (i)));
	}
}

extern 	CString g_sdomain;
#ifdef ENTERPRISE_VERSION
CString g_bMain;
#endif
void CDBServerDlg::LoadBranchInfo()
{
#ifdef ENTERPRISE_VERSION
	try
	{
	ReleaseBranchDB();
 	CArray<CStringArray, CStringArray>g_List1array;
	{
    MyLock lock("savebranchinfo");
 	CFile fp;
	CString path=g_mainpath+"\\branchinfo.dat";
	if(::PathFileExists (path)==0)
	{
		return;
	}
	fp.Open (path, CFile::modeRead);

	DWORD leng=fp.GetLength ();
	if(leng<sizeof(DWORD)*2)
	{
		fp.Close ();return;
	}
	DWORD flag;
	fp.Seek(-sizeof(DWORD),CFile::end);
	fp.Read (&flag, sizeof(DWORD));
	if(flag!=889900)
	{
		fp.Close ();return;
	}
	fp.SeekToBegin ();
 
	DWORD arraysize;
	fp.Read (&arraysize, sizeof(DWORD));
	if(arraysize>20)
	{
		fp.Close ();
		return;
	}
	BYTE *pData=new BYTE[leng-sizeof(DWORD)];
	fp.Read (pData,leng-sizeof(DWORD));
	fp.Close ();
	CMemFile memfile;
	memfile.Attach (pData,leng-sizeof(DWORD));
	CArchive ar(&memfile, CArchive::load);
    g_List1array.SetSize(arraysize, 1);
	for(int ii=0; ii<g_List1array.GetSize (); ii++)
	{
		   g_List1array.ElementAt (ii).Serialize (ar);
	}
	ar.Close();
	memfile.Detach ();
	delete []pData;
	}
	if(g_List1array.GetSize()==0)return;
	SoftKey ytSoftKey;
	if(ytSoftKey.Ini()==0)
	{
	long value[8];
	double f[8];
	TCHAR s0[50]=_T(""),s1[50]=_T(""),s2[50]=_T(""),s3[50]=_T(""),s4[50]=_T(""),s5[50]=_T(""),s6[50]=_T(""),s7[50]=_T("");
	//运行自定义函数
	int ret=ytSoftKey.getdata(&value[0],&value[1],&value[2],&value[3],&value[4],&value[5],&value[6],&value[7],
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		g_sdomain="";
	}
	else
	    g_sdomain=s1; 

	}

	CString str,str2,localname,rights;
	for(int i=0; i<g_List1array.GetSize (); i++)
	{
		if(g_sdomain==g_List1array.ElementAt (i).ElementAt (0))
		{
			if(g_List1array.ElementAt (i).GetSize ()>5)
			    rights=g_List1array.ElementAt (i).ElementAt (5);break;
		}
	}

	for( i=0; i<g_List1array.GetSize (); i++)
	{
		CString branchname=g_List1array.ElementAt (i).ElementAt (1);
 		CString branchip=g_List1array.ElementAt (i).ElementAt (2);
 		CString domain=g_List1array.ElementAt (i).ElementAt (0);
		CString dir=g_mainpath+"\\数据\\"+branchname;
		if(g_sdomain==g_List1array.ElementAt (i).ElementAt (0))
		{
			localname=branchname;
			g_bMain=g_List1array.ElementAt (i).ElementAt (3);
			continue;
		}
		CString branchname2=","+branchname+",";
		if(rights.Find (branchname2)==-1)continue;
#ifdef SQLSERVER_VERSION
		if(1)//::PathFileExists (dir))
		{
/////////////////////////
					g_branchdbarray.Add (NULL);
					g_branchnamearray.Add (branchname);
					g_branchdb2array.Add (NULL);
					g_branchname2array.Add (branchname);

					g_branchiparray.Add (branchip);
					g_branchdomainarray.Add (domain);
		}
#else
		if(::PathFileExists (dir))
		{
			CString tempdir=dir+"\\temp";
			if(::PathFileExists (tempdir+"\\db.mdb"))
			{
				for(int j=3000; j>2000; j--)
				{
					str.Format ("%s%d.mdb", dir+"\\", j);
					::DeleteFile (str);
					str2.Format ("%s%d.mdb", tempdir+"\\", j);
					::CopyFile (str2, str, 0);
				}	
				str.Format ("%sdb.mdb", dir+"\\");
				::DeleteFile (str);
				str2.Format ("%sdb.mdb", tempdir+"\\");
				::CopyFile (str2, str, 0);
			}
/////////////////////////
		    str.Format ("%sdb.mdb", dir+"\\");
			if(::PathFileExists (str))
			{
				CDatabase *db=new CDatabase;
				CString strCon;
				strCon.Format("DRIVER=Microsoft Access Driver (*.mdb);DSN='';DBQ=%s;PWD=lijialyfz",str);
				try
				{
				if(db->OpenEx(strCon,CDatabase::noOdbcDialog))
				{
					g_branchdbarray.Add (db);
					g_branchnamearray.Add (branchname);
					g_branchdb2array.Add (db);
					g_branchname2array.Add (branchname);

					g_branchiparray.Add (branchip);
					g_branchdomainarray.Add (domain);
				    for(int j=3000; j>2000; j--)
					{
						str.Format ("%s%d.mdb", dir+"\\", j);
						if(::PathFileExists (str))
						{
							CDatabase *db=new CDatabase;
							CString strCon;
							strCon.Format("DRIVER=Microsoft Access Driver (*.mdb);DSN='';DBQ=%s;PWD=lijialyfz",str);
							if(db->OpenEx(strCon,CDatabase::noOdbcDialog))
							{
								g_branchdbarray.Add (db);
								str.Format ("%d", j);
								g_branchnamearray.Add (branchname+str);
								g_branchiparray.Add (branchip);
								g_branchdomainarray.Add (domain);
							}
							else
								delete db;
						}
					}
				}
				else
					delete db;
				}
				catch(...)
				{
					delete db;
				}
			}
		}
#endif
	}
	g_branchdbarray.Add (NULL);			
	g_branchnamearray.Add (localname);	
	g_branchiparray.Add ("xxx");
	g_branchdomainarray.Add (g_sdomain);
	}
	catch(...)
	{
	}
#endif
}

void CDBServerDlg::ReleaseBranchDB()
{
#ifdef ENTERPRISE_VERSION
	try
	{
	for(int i=0;i<g_branchdbarray.GetSize (); i++)
	{
		if(g_branchdbarray.ElementAt (i))
		{
		g_branchdbarray.ElementAt (i)->Close ();
		delete g_branchdbarray.ElementAt (i);
		}
	}
	g_branchdbarray.RemoveAll();
	g_branchdb2array.RemoveAll();
	g_branchnamearray.RemoveAll();
	g_branchname2array.RemoveAll();
	g_branchiparray.RemoveAll();
	g_branchdomainarray.RemoveAll();
	}
	catch(...)
	{
		WriteLogin("ReleaseBranchDB出错");
	}
#endif
}
//savebranchinfo

void CDBServerDlg::LoadBranchInfo2()
{
#ifdef ENTERPRISE_VERSION
	try
	{
	ReleaseBranchDB();
 	CArray<CStringArray, CStringArray>g_List1array;
	{
    MyLock lock("savebranchinfo");
 	CFile fp;
	CString path=g_mainpath+"\\branchinfo.dat";
	if(::PathFileExists (path)==0)
	{
		return;
	}
	fp.Open (path, CFile::modeRead);
	DWORD leng=fp.GetLength ();
	if(leng<sizeof(DWORD)*2)
	{
		fp.Close ();return;
	}

	DWORD flag;
	fp.Seek(-sizeof(DWORD),CFile::end);
	fp.Read (&flag, sizeof(DWORD));
	if(flag!=889900)
	{
		fp.Close ();return;
	}
	fp.SeekToBegin ();
 
	DWORD arraysize;
	fp.Read (&arraysize, sizeof(DWORD));
	if(arraysize>20)
	{
		fp.Close ();
		return;
	}
	BYTE *pData=new BYTE[leng-sizeof(DWORD)];
	fp.Read (pData,leng-sizeof(DWORD));
	fp.Close ();
	CMemFile memfile;
	memfile.Attach (pData,leng-sizeof(DWORD));
	CArchive ar(&memfile, CArchive::load);
    g_List1array.SetSize(arraysize, 1);
	for(int ii=0; ii<g_List1array.GetSize (); ii++)
	{
		   g_List1array.ElementAt (ii).Serialize (ar);
	}
	ar.Close();
	memfile.Detach ();
	delete []pData;
	}
	if(g_List1array.GetSize()==0)return;
 			
 
	SoftKey ytSoftKey;
	if(ytSoftKey.Ini()==0)
	{
	long value[8];
	double f[8];
	TCHAR s0[50]=_T(""),s1[50]=_T(""),s2[50]=_T(""),s3[50]=_T(""),s4[50]=_T(""),s5[50]=_T(""),s6[50]=_T(""),s7[50]=_T("");
	//运行自定义函数
	int ret=ytSoftKey.getdata(&value[0],&value[1],&value[2],&value[3],&value[4],&value[5],&value[6],&value[7],
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		g_sdomain="";
	}
	else
	    g_sdomain=s1; 

	}

	CString str,str2,localname,rights;
	for(int i=0; i<g_List1array.GetSize (); i++)
	{
		if(g_sdomain==g_List1array.ElementAt (i).ElementAt (0))
		{
			if(g_List1array.ElementAt (i).GetSize ()>5)
			    rights=g_List1array.ElementAt (i).ElementAt (5);break;
		}
	}

	for( i=0; i<g_List1array.GetSize (); i++)
	{
		CString branchname=g_List1array.ElementAt (i).ElementAt (1);
 		CString branchip=g_List1array.ElementAt (i).ElementAt (2);
 		CString domain=g_List1array.ElementAt (i).ElementAt (0);
		CString dir=g_mainpath+"\\数据\\"+branchname;
		if(g_sdomain==g_List1array.ElementAt (i).ElementAt (0))
		{
			localname=branchname;
			g_bMain=g_List1array.ElementAt (i).ElementAt (3);
			continue;
		}
		CString branchname2=","+branchname+",";
		if(rights.Find (branchname2)==-1)continue;
#ifdef SQLSERVER_VERSION
		if(1)//::PathFileExists (dir))
		{
////////////////////////
					g_branchdbarray.Add (NULL);
					g_branchnamearray.Add (branchname);
					g_branchdb2array.Add (NULL);
					g_branchname2array.Add (branchname);

					g_branchiparray.Add (branchip);
					g_branchdomainarray.Add (domain);
		}
#else
		if(::PathFileExists (dir))
		{
			CString tempdir=dir+"\\temp";
			if(::PathFileExists (tempdir+"\\db.mdb"))
			{
				for(int j=3000; j>2000; j--)
				{
					str.Format ("%s%d.mdb", dir+"\\", j);
					::DeleteFile (str);
					str2.Format ("%s%d.mdb", tempdir+"\\", j);
					::CopyFile (str2, str, 0);
				}	
				str.Format ("%sdb.mdb", dir+"\\");
				::DeleteFile (str);
				str2.Format ("%sdb.mdb", tempdir+"\\");
				::CopyFile (str2, str, 0);
 
			}
/////////////////////////
		    str.Format ("%sdb.mdb", dir+"\\");
			if(::PathFileExists (str))
			{
				CDatabase *db=new CDatabase;
				CString strCon;
				strCon.Format("DRIVER=Microsoft Access Driver (*.mdb);DSN='';DBQ=%s;PWD=lijialyfz",str);
				try
				{
				if(db->OpenEx(strCon,CDatabase::noOdbcDialog))
				{
					g_branchdbarray.Add (db);
					g_branchnamearray.Add (branchname);
					g_branchdb2array.Add (db);
					g_branchname2array.Add (branchname);

					g_branchiparray.Add (branchip);
					g_branchdomainarray.Add (domain);
				    for(int j=3000; j>2000; j--)
					{
						str.Format ("%s%d.mdb", dir+"\\", j);
						if(::PathFileExists (str))
						{
							CDatabase *db=new CDatabase;
							CString strCon;
							strCon.Format("DRIVER=Microsoft Access Driver (*.mdb);DSN='';DBQ=%s;PWD=lijialyfz",str);
							if(db->OpenEx(strCon,CDatabase::noOdbcDialog))
							{
								g_branchdbarray.Add (db);
								str.Format ("%d", j);
								g_branchnamearray.Add (branchname+str);
								g_branchiparray.Add (branchip);
								g_branchdomainarray.Add (domain);
							}
							else
								delete db;
						}
					}
				}
				else
					delete db;
				}
				catch(...)
				{
					delete db;
				}
			}
		}
#endif
	}
	g_branchdbarray.Add (NULL);
	g_branchnamearray.Add (localname);
	g_branchiparray.Add ("xxx");
	g_branchdomainarray.Add (g_sdomain);
	}
	catch(...)
	{
	}
#endif
}
void SortArray(CStringArray &datearray)
{
	try
	{
	CString  strtemp;
	float  ftemp;
	int last = datearray.GetSize () - 1;
	bool sorted = true;

	do {
		sorted = true;
		for (int i = 0; i < last; i++) 
		{
			if (datearray[i] < datearray[i + 1])
			{
				strtemp = datearray[i];
				datearray[i] = datearray[i + 1];
				datearray[i + 1] = strtemp;

 

				sorted = false;
			}

		}
	  last--;
	} while (!sorted);
	}
	catch(...)
	{
		WriteLogin("SortArray出错");
	}
}
int CheckPhoneType(CString phoneno)//移动:0 联通:1 电信:2 小灵通:3 未知:-1
{
	if(phoneno.IsEmpty ())return -1;
	for(int i=0; i<phoneno.GetLength (); i++)
	{
		if(phoneno.GetAt (i)<'0'||phoneno.GetAt (i)>'9')return -1;
	}
	if(phoneno.GetAt (0)=='1')
	{
		if(phoneno.GetLength ()!=11)
	    	return -1;
		int mobile[]={139,138,137,136,135,134,159,158,152,151,150,157,188,187,144,182,147,183};
		int unicom[]={130,131,132,155,156,186,185};
		int telecom[]={133,153,189,180};

		for(i=0; i<sizeof(mobile)/sizeof(int); i++)
		{
			if(mobile[i]==atoi(phoneno.Left (3)))
			{
				return 0;
			}
		}
		for(i=0; i<sizeof(unicom)/sizeof(int); i++)
		{
			if(unicom[i]==atoi(phoneno.Left (3)))
			{
				return 1;
			}
		}
		for(i=0; i<sizeof(telecom)/sizeof(int); i++)
		{
			if(telecom[i]==atoi(phoneno.Left (3)))
			{
				return 2;
			}
		}
		return -1;
	}
/*	else if(phoneno.GetAt (0)=='0')
	{
		if(phoneno.GetLength ()>=10 && phoneno.GetLength ()<=12)
		{
			return 3;
		}
	}*/
	return -1;
}
void CDBServerDlg::CheckMemberMsg()
{
	try
	{
    g_curdb=&g_db;
	CString sql="delete from sendreg where [log]='0/0'";
    MyExecuteSQL (&g_db, sql);


		int covertrate=100;
		CString spoint;
		{
	CRecordset myset(g_curdb);
	CString	sql="select * from version";
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("rate2", sql);
	myset.Close();
	covertrate=atoi(sql);
	if(covertrate==0)covertrate=100;
		}



	CString filter;
     
	CArray<CStringArray, CStringArray>rulearray;
	CArray<CStringArray, CStringArray>memberarray;
	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from msgtemp2";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	rulearray.SetSize(count , 1 );
	CRstmsgtemp2 rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    DWORD ii=0; 
	while(!rsSt.IsEOF())
	{
    	rulearray.ElementAt (ii).RemoveAll ();
		rulearray.ElementAt (ii).Add(rsSt.name) ;
		rulearray.ElementAt (ii).Add(rsSt.content1) ;
		rulearray.ElementAt (ii).Add(rsSt.content2) ;
		rulearray.ElementAt (ii).Add(rsSt.check1) ;
		rulearray.ElementAt (ii).Add(rsSt.check2) ;
		rulearray.ElementAt (ii).Add(rsSt.point) ;
		ii++;
		rsSt.MoveNext();if(rulearray.GetSize ()<=ii)break;
	}
	rsSt.Close();rulearray.SetSize(ii , 1 );
	}
	if(rulearray.GetSize()==0)return;
/////////////
	{
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from membermanage"; if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	memberarray.SetSize(atol(sql) , 1 );
	RstMemberReg rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    DWORD ii=0;
	if(covertrate!=100)
	{
	while(!rsSt.IsEOF())
	{
    	memberarray.ElementAt (ii).RemoveAll ();
		memberarray.ElementAt (ii).Add(rsSt.m_memberno) ;
		memberarray.ElementAt (ii).Add(rsSt.m_name) ;
		memberarray.ElementAt (ii).Add(rsSt.m_sex) ;
		memberarray.ElementAt (ii).Add(rsSt.m_phone) ;
 

		spoint.Format ("%d", atoi(rsSt.m_money)*covertrate/100);
		memberarray.ElementAt (ii).Add(spoint) ;

		memberarray.ElementAt (ii).Add(rsSt.m_sendmark1) ;
		memberarray.ElementAt (ii).Add(rsSt.m_sendmark2) ;
		ii++;
		rsSt.MoveNext();if(memberarray.GetSize ()<=ii)break;
	}
	}
	else
	{
	while(!rsSt.IsEOF())
	{
    	memberarray.ElementAt (ii).RemoveAll ();
		memberarray.ElementAt (ii).Add(rsSt.m_memberno) ;
		memberarray.ElementAt (ii).Add(rsSt.m_name) ;
		memberarray.ElementAt (ii).Add(rsSt.m_sex) ;
		memberarray.ElementAt (ii).Add(rsSt.m_phone) ;
		memberarray.ElementAt (ii).Add(rsSt.m_money) ;
		memberarray.ElementAt (ii).Add(rsSt.m_sendmark1) ;
		memberarray.ElementAt (ii).Add(rsSt.m_sendmark2) ;
		ii++;
		rsSt.MoveNext();if(memberarray.GetSize ()<=ii)break;
	}
	}
	rsSt.Close();memberarray.SetSize(ii , 1 );
	}

	CString memberno,name,sex,phone,point,mark1,mark2,rulename,rulecheck1,rulecheck2,rulepoint,rulecontent1,rulecontent2;
	for(int i=0; i<memberarray.GetSize(); i++)
	{
		memberno=memberarray.ElementAt (i).ElementAt (0);
		name=memberarray.ElementAt (i).ElementAt (1);
		sex=memberarray.ElementAt (i).ElementAt (2);
		phone=memberarray.ElementAt (i).ElementAt (3);
		point=memberarray.ElementAt (i).ElementAt (4);
		mark1=","+memberarray.ElementAt (i).ElementAt (5)+",";
		mark2=","+memberarray.ElementAt (i).ElementAt (6)+",";
		if(atoi(point)==0)continue;
		if(phone.IsEmpty ())continue;
		if(-1==CheckPhoneType(phone))continue;
		for(int j=0; j<rulearray.GetSize (); j++)
		{
			if(mark1.GetLength ()>4000)break;
			rulename=","+rulearray.ElementAt (j).ElementAt (0)+",";
			rulecontent1=rulearray.ElementAt (j).ElementAt (1);
			rulecontent2=rulearray.ElementAt (j).ElementAt (2);
			rulecheck1=rulearray.ElementAt (j).ElementAt (3);
			rulecheck2=rulearray.ElementAt (j).ElementAt (4);
			rulepoint=rulearray.ElementAt (j).ElementAt (5);
			if(atoi(rulecheck1)==0 && atoi(rulecheck2)==0)continue;

			if(atoi(rulecheck1))
			{
				if(rulecontent1.IsEmpty ())continue;
				if(mark1.Find (rulename)!=-1)continue;
				if(atoi(point)>=atoi(rulepoint))continue;
				if(atoi(point)<atoi(rulepoint)*80/100)continue;
				if(sex=="男")
				    rulecontent1.Replace ("xxx先生/女士", name+"先生");
				else
				    rulecontent1.Replace ("xxx先生/女士", name+"女士");

				int count=GetLengthEx(rulecontent1)/MSG_LENGTH;
				if(GetLengthEx(rulecontent1)%MSG_LENGTH)
					count++;
				int phonenum=1;
				count*=phonenum;
				CString scount;
				scount.Format ("%d", count);
				CString timestamp=CTime::GetCurrentTime ().Format ("%Y%m%d%H%M%S");
				CString sql;
				mark1.TrimLeft (",");
				mark1.TrimRight (",");
				if(mark1.IsEmpty ()==0)
				    mark1+=",";
				rulename.TrimLeft (",");
				rulename.TrimRight (",");
				mark1+=rulename;
				sql="update membermanage set sendmark1='"+mark1+"' where memberno='"+memberno+"'";
                MyExecuteSQL (&g_db, sql);
				mark1=","+mark1+",";

				sql="insert into sendreg([phones],[content],[timestamp],[msgcount],[status],[issended],[isautosend],[ren]) values\
('"+phone+"','"+rulecontent1+"','"+timestamp+"','"+scount+"','0','0','0','系统自动发送')";
                 MyExecuteSQL (&g_db, sql);
			}
		}
///////////////////
		BOOL bSended=0;
		for( j=0; j<rulearray.GetSize (); j++)
		{
			if(mark2.GetLength ()>4000)break;
			if(bSended)break;
			rulename=","+rulearray.ElementAt (j).ElementAt (0)+",";
			rulecontent1=rulearray.ElementAt (j).ElementAt (1);
			rulecontent2=rulearray.ElementAt (j).ElementAt (2);
			rulecheck1=rulearray.ElementAt (j).ElementAt (3);
			rulecheck2=rulearray.ElementAt (j).ElementAt (4);
			rulepoint=rulearray.ElementAt (j).ElementAt (5);
			if(atoi(rulecheck1)==0 && atoi(rulecheck2)==0)continue;
			if(atoi(rulecheck2))
			{
				if(rulecontent2.IsEmpty ())continue;
				if(mark2.Find (rulename)!=-1)continue;
				if(atoi(point)<atoi(rulepoint))continue;
 
				if(sex=="男")
				    rulecontent2.Replace ("xxx先生/女士", name+"先生");
				else
				    rulecontent2.Replace ("xxx先生/女士", name+"女士");

				int count=GetLengthEx(rulecontent2)/MSG_LENGTH;
				if(GetLengthEx(rulecontent2)%MSG_LENGTH)
					count++;
				int phonenum=1;
				count*=phonenum;
				CString scount;
				scount.Format ("%d", count);
				CString timestamp=CTime::GetCurrentTime ().Format ("%Y%m%d%H%M%S");
				CString sql;
				mark2.TrimLeft (",");
				mark2.TrimRight (",");
				if(mark2.IsEmpty ()==0)
				    mark2+=",";
				rulename.TrimLeft (",");
				rulename.TrimRight (",");
				mark2+=rulename;
				sql="update membermanage set sendmark2='"+mark2+"' where memberno='"+memberno+"'";
                MyExecuteSQL (&g_db, sql);
				mark2=","+mark2+",";

				sql="insert into sendreg([phones],[content],[timestamp],[msgcount],[status],[issended],[isautosend],[ren]) values\
('"+phone+"','"+rulecontent2+"','"+timestamp+"','"+scount+"','0','0','0','系统自动发送')";
                 MyExecuteSQL (&g_db, sql);
				 bSended=1;
			}
		}
	}
	}
	catch(...)
	{
		WriteLogin("出错2");
	}
}

void CDBServerDlg::CheckBakState()
{
	try
	{
	g_curdb=&g_db;
	CString filter;
	CArray<CStringArray, CStringArray>g_List1array;
	CRecordset myset(g_curdb);
	CString	sql="select count(*) as cot from bakstate";if(!filter.IsEmpty ())sql+=" where "+filter;
	myset.Open (CRecordset::forwardOnly, sql);
	myset.GetFieldValue ("cot", sql);
	myset.Close();
	int count=atol(sql);
	g_List1array.SetSize(count , 1 );
	CRstbakstate rsSt;if(!filter.IsEmpty ())rsSt.m_strFilter =filter;
	rsSt.Open();
    int ii=0; 
	while(!rsSt.IsEOF())
	{
    	g_List1array.ElementAt (ii).RemoveAll ();
		g_List1array.ElementAt (ii).Add(rsSt.date) ;
		g_List1array.ElementAt (ii).Add(rsSt.photo) ;
		g_List1array.ElementAt (ii).Add(rsSt.info) ;
		ii++;
		rsSt.MoveNext();if(g_List1array.GetSize ()<=ii)break;
	}
	rsSt.Close();g_List1array.SetSize(ii , 1 );

	while(g_List1array.GetSize ()>7)
	{
		CString sql="delete from bakstate where [date]='"+g_List1array.ElementAt (0).ElementAt (0)+"'";
		MyExecuteSQL(&g_db, sql);
		g_List1array.RemoveAt(0);
	}

	CString path;
	path.Format ("%s\\log.txt", g_mainpath);
	if(::PathFileExists (path))
	{
	CString str;
	CStdioFile fp;
	if(fp.Open (path, CFile::modeRead))
	{
		CString temp;
		fp.ReadString (temp);
		CString date=temp;date.TrimRight ();
		while(!feof(fp.m_pStream)) 
		{
			fp.ReadString (temp);
		    str+=temp;
		}
		fp.Close ();
		if(date.GetLength ()!=10)return;
		BOOL bBak=0;
		for(int i=0; i<g_List1array.GetSize (); i++)
		{
			if(date==g_List1array.ElementAt (i).ElementAt (0))
			{
				bBak=1;
				break;
			}
		}
		if(bBak==0)
		{
		CString state1="0";
		CString state2="0";
		if(str.Find ("照片备份成功")!=-1)state1="1";
		if(str.Find ("资料备份成功")!=-1)state2="1";
		sql="insert into bakstate([date],[photo],[info])values('"+date+"','"+state1+"','"+state2+"')";
		MyExecuteSQL(&g_db, sql);
		}
		else
		{
		CString state1="0";
		CString state2="0";
		if(str.Find ("照片备份成功")!=-1)state1="1";
		if(str.Find ("资料备份成功")!=-1)state2="1";
		sql="update bakstate set [photo]='"+state1+"',[info]='"+state2+"' where [date]='"+date+"'";
		MyExecuteSQL(&g_db, sql);
		}

		//判断昨天
		CTime tm=CTime::GetCurrentTime ();
		CTimeSpan dt(1, 0, 0, 0);
		tm-=dt;
		CString yesterday=tm.Format ("%Y-%m-%d");
		for(i=0; i<g_List1array.GetSize (); i++)
		{
			if(yesterday==g_List1array.ElementAt (i).ElementAt (0))return;
		}
		if(yesterday==date)return;
		sql="insert into bakstate([date],[photo],[info])values('"+yesterday+"','0','0')";
		MyExecuteSQL(&g_db, sql);
	}
	else
	{
		CTime tm=CTime::GetCurrentTime ();
		CTimeSpan dt(1, 0, 0, 0);
		tm-=dt;		
		sql="insert into bakstate([date],[photo],[info])values('"+tm.Format ("%Y-%m-%d")+"','0','0')";
		MyExecuteSQL(&g_db, sql);
	}
	}
	else
	{
		CTime tm=CTime::GetCurrentTime ();
		CTimeSpan dt(1, 0, 0, 0);
		tm-=dt;		
		for(int i=0; i<g_List1array.GetSize (); i++)
		{
			if(tm.Format ("%Y-%m-%d")==g_List1array.ElementAt (i).ElementAt (0))return;
		}

		sql="insert into bakstate([date],[photo],[info])values('"+tm.Format ("%Y-%m-%d")+"','0','0')";
		MyExecuteSQL(&g_db, sql);
	}
	}
	catch(...)
	{
		WriteLogin("出错3");
	}
}
//数据备份

CString CDBServerDlg::GetRegCode(long m_id, long m_time1, long m_time2 )
{
	TCHAR DevicePath[ 260];
	if(FindPort(0,DevicePath)!=0)
		return "";
	int version;
	GetIDVersion((DWORD*)&m_id, &version, DevicePath);
	long d[8];double f[8];
	long idtemp=123456;
	char s0[50]="",s1[50]="",s2[50]="",s3[50]="",s4[50]="",s5[50]="",s6[50]="",s7[50]="";
	//运行自定义函数
	SoftKey ytSoftKey;
	int ret=ytSoftKey.Ini();
	if (ret!=0 )
	{
		return "";
	}
	ret=ytSoftKey.timedog1(&m_id,&idtemp,&m_time1,&m_time2,&d[4],&d[5],&d[6],&d[7],
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		return "";
	}
	CString str="";
	CString temp,temp2;
/////////////////////////////////////////
	temp.Format ("%d", abs(m_id));
	int leng=temp.GetLength ();
	if(m_id<0)
		temp2="1";
	else
		temp2="0";
	temp=temp2+temp;
	temp2.Format ("%02d", leng);
	temp=temp2+temp;
	str+=temp;
//////////////////////////////////两位长度, 1为负, 0为正, 数据区
	temp.Format ("%d", abs(m_time1));
	  leng=temp.GetLength ();
	if(m_time1<0)
		temp2="1";
	else
		temp2="0";
	temp=temp2+temp;
	temp2.Format ("%02d", leng);
	temp=temp2+temp;
	str+=temp;
//////////////////////////////////两位长度, 1为负, 0为正, 数据区
	temp.Format ("%d", abs(m_time2));
	  leng=temp.GetLength ();
	if(m_time2<0)
		temp2="1";
	else
		temp2="0";
	temp=temp2+temp;
	temp2.Format ("%02d", leng);
	temp=temp2+temp;
	str+=temp;
//////////////////////////////////两位长度, 1为负, 0为正, 数据区
	temp.Format ("%d", abs(idtemp));
	  leng=temp.GetLength ();
	if(idtemp<0)
		temp2="1";
	else
		temp2="0";
	temp=temp2+temp;
	temp2.Format ("%02d", leng);
	temp=temp2+temp;
	str+=temp;
	return str;
}
int g_ndogtimes=0;
void CDBServerDlg::CheckRegCode()
{ 
	char path[MAX_PATH];
	::GetSystemDirectory (path, MAX_PATH);
	CString sysdir=path;
	sysdir+="\\authcode.txt";
	CStdioFile fp;
	CString authcode;
	if(fp.Open (sysdir, CFile::modeRead))
	{
		fp.ReadString (authcode);
		fp.Close ();
	}
 	::DeleteFile (sysdir);
	authcode.TrimLeft ();
	authcode.TrimRight ();
	authcode.Replace ("\n", "");
	authcode.Replace ("\r", "");
	if(authcode.GetLength ()!=240)
	{
		return;
	}

	TCHAR DevicePath[ 260];
	if(FindPort(0,DevicePath)!=0)
		return;
    DWORD OutID;
	int version;
	GetIDVersion(&OutID, &version, DevicePath);


	CString str1,str2,str3,str4,str5;
	str1=authcode.Mid (0, 48);
	str2=authcode.Mid (48, 48);
	str3=authcode.Mid (96, 48);
	str4=authcode.Mid (144, 48);
	str5=authcode.Mid (192, 48);
 
	SoftKey ytSoftKey;
	int ret=ytSoftKey.Ini();
	if (ret!=0 )
	{
		return  ;
	}
	long d[8];double f[8];
	char s0[50]="",s1[50]="",s2[50]="",s3[50]="",s4[50]="",s5[50]="",s6[50]="",s7[50]="";
	//运行自定义函数

	sprintf(s0, "%s", str1);
	sprintf(s1, "%s", str2);
	sprintf(s2, "%s", str3);
	sprintf(s3, "%s", str4);
	sprintf(s4, "%s", str5);
	//运行自定义函数
   
    ret=ytSoftKey.timedog2(&d[0],&d[1],&d[2],&d[3],&d[4],&d[5],&d[6],&d[7],
				&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7],
				s0,s1,s2,s3,s4,s5,s6,s7);
	if(ret!=0 && ret!=-43)
	{
		return;
	}
	str1=s0;
	str2=s1;
	str3=s2;
	str4=s3;
	str5=s4;
	authcode=str1;
	authcode+=str2;
	authcode+=str3;
	authcode+=str4;
	authcode+=str5; 
 


	str1+=str2;
	str3+=str4;
	DWORD id=atoi(str5.Right  (8));
	str5=str5.Left (12);
	if(id!=OutID)
	{
		return;
	}


	TCHAR HKey[20]="ffffffff",LKey[20]="ffffffff";
	TCHAR WHKey[41]="0",WLKey[41]="0";
   	TCHAR  year[10],month[10],day[10],hour[10],minute[10],second[10];
	sprintf(WHKey, "%s", str1);
	sprintf(WLKey, "%s", str3);

	CString temp;
	temp=str5.Left (4);
	str5=str5.Right (8);
	sprintf(year, "%s", temp);
	temp=str5.Left (2);
	str5=str5.Right (6);
	sprintf(month, "%s", temp);

	temp=str5.Left (2);
	str5=str5.Right (4);
	sprintf(day, "%s", temp);
	temp=str5.Left (2);
	str5=str5.Right (2);
	sprintf(hour, "%s", temp);
	sprintf(minute, "%s", str5);
	sprintf(second, "%s", "0");

    ret=WriteTimeAuthToEprom(30128, HKey, LKey, WHKey, WLKey, id,year,month,day,hour,minute,DevicePath);
	if(ret==0)
	{
		TCHAR  year2[10],month2[10],day2[10],hour2[10],minute2[10],second2[10];
		GetRunTimer(year2, month2, day2, hour2, minute2, second2, DevicePath);
		DWORD time1,time2;

        time1=ConvertStringToTimerReal(year, month, day, hour, minute, second);
 
		sprintf(second2, "%s", "0");
        time2=ConvertStringToTimerReal(year2, month2, day2, hour2, minute2, second2);
		if(time1>time2)
             ConvertTimerToStringReal(time1-time2, year, month, day, hour, minute, second);
		else
		{
			sprintf(year, "%s", "0");
			sprintf(month, "%s", "0");
			sprintf(day, "%s", "0");
			sprintf(hour, "%s", "0");
			sprintf(minute, "%s", "0");
		}
		g_ndogtimes++;
	 //	str1.Format ("写入%d次 %d 年 %d 月 %d 日 %d 小时 %d 分", g_ndogtimes, atoi(year), atoi(month), atoi(day), atoi(hour), atoi(minute));
	//	WriteLogin(str1);
	//	AfxMessageBox((str1));
	}
	else
	{
	//	AfxMessageBox(("授权申请码错误, 请重新向经销商索取!"));
		return;
	}
}
//singleincome 
BOOL CDBServerDlg::PreTranslateMessage(MSG* pMsg) 
{
 	if(pMsg->message==WM_KEYDOWN)
	{
		switch (pMsg->wParam)
		{
		case 67:
			AfxMessageBox("c");
			break;
		case VK_F1:
			CString str;
			if(g_conniparray.GetSize()==0)str="当前无客户端连接至服务器!";
			for(int i=0; i<g_conniparray.GetSize(); i++)
			{
				str+="\r\n连接ip:"+g_conniparray.ElementAt(i);
			}
			AfxMessageBox(str);
#ifdef  CONNCOUNT_VERSION
		  //  CStringArray g_conniparray;
#endif
			return 1;
		}
	}
	return CDialog::PreTranslateMessage(pMsg);
}

void CDBServerDlg::GenUPhoneData()
{
	MyLock lock("processChatMessageRequestxiao");
	CArray<int,int>codearray;
	codearray.Add (80);
	codearray.Add (90);
	codearray.Add (11);
	codearray.Add (138);
	codearray.Add (24);
	codearray.Add (181);
	codearray.Add (65);
 	codearray.Add (56); 
	codearray.Add (179);
 	codearray.Add (53); 
	CFile fp;
	CString savepath,g_path1;
 	g_path1=GetPathFromNetShareName("电话录音(管理软件)$");
	if(g_path1.IsEmpty ())return;

	try
	{
		int aa=0;
		g_curdb=&g_db;
	    savepath.Format ("%s\\uphonedata%d.dat", g_path1, aa);
	::DeleteFile (savepath);
	if(fp.Open (savepath, CFile::modeCreate|CFile::modeWrite)==0)
	{
		WriteLogin("更新电精灵数据出错");
		return;
	}
	CConnectSocket consock;
	consock.m_pConndb =&g_db;
 

	for(int i=0; i<codearray.GetSize (); i++)
	{
		BYTE code=codearray.ElementAt (i);
		DWORD length,arraysize;
		BYTE *pReturn=NULL;
		consock.GetDataFromCode(code, &pReturn, length, arraysize, "");
		fp.Write (&code, sizeof(BYTE));
		fp.Write (&length, sizeof(DWORD));
		fp.Write (&arraysize, sizeof(DWORD));
		fp.Write (pReturn, length);
	}
	fp.Close ();
	}
	catch(...)
	{
		WriteLogin("获取来电精灵数据出错");
	}
}
//initlia

void CDBServerDlg::LoadDB()
{
	CString path;
	CString sql;
	sql="delete from historydb";
	MyExecuteSQL(&g_db, sql);
    CDatabase g_masterdb;
	try
	{
		CString strCon;			
		strCon.Format(_T("driver={SQL Server};Server=%s\\SQLEXPRESS;DATABASE=master;UID=sa;PWD=ly1234;"), g_localname);
		g_masterdb.OpenEx(strCon,CDatabase::noOdbcDialog); 
	}
    catch(CDBException * e)
    {
	}
	for(int i=CTime::GetCurrentTime ().GetYear ()-1; i>=2009; i--)
	{
		CDatabase *db=new CDatabase;
		try
		{
			CString strCon;			
			strCon.Format(_T("driver={SQL Server};Server=%s\\SQLEXPRESS;DATABASE=%d;UID=sa;PWD=ly1234;"), g_localname, i);
			db->OpenEx(strCon,CDatabase::noOdbcDialog);
		 
			yeararray.Add (i);
			dbarray.Add (db);
			sql.Format ("insert into [historydb]([year])values('%d')", i);
			MyExecuteSQL(&g_db, sql);
		}
		catch(CDBException * e)
		{
			CString path,path2,sql;
			path.Format ("%s\\数据\\%d.mdf", g_mainpath, i);
			path2.Format ("%s\\数据\\%d_log.LDF", g_mainpath, i);
			if(::PathFileExists (path))
			{
				BOOL bLog=0;
				if( ::PathFileExists(path2))
				{
					bLog=1;
				}  
				g_masterdb.SetQueryTimeout(600);
				
				if(bLog)
					sql.Format("exec sp_attach_db '%d',@filename1='%s',@filename2='%s'", i, path, path2);
				else
					sql.Format("exec sp_attach_db '%d',@filename1='%s'", i, path);	
				try
				{
					g_masterdb.ExecuteSQL (sql);   
				}
				catch(CDBException * e)
				{
					WriteLogin(e->m_strError);
					WriteLogin("历史数据库初始化失败!!");
					g_masterdb.SetQueryTimeout(10);
					break;
				}
				g_masterdb.SetQueryTimeout(10);

         	CString strCon;			
			strCon.Format(_T("driver={SQL Server};Server=%s\\SQLEXPRESS;DATABASE=%d;UID=sa;PWD=ly1234;"), g_localname, i);
			db->OpenEx(strCon,CDatabase::noOdbcDialog);
		 
			yeararray.Add (i);
			dbarray.Add (db);
			sql.Format ("insert into [historydb]([year])values('%d')", i);
			MyExecuteSQL(&g_db, sql);

			}
			else
				break;
		}
	}
	g_masterdb.Close ();
}


void CDBServerDlg::AddOneConn()
{
	try
	{
	MyLock lock("AddOneConnxiao");
		if(g_nDBCount>=200)
		{
			WriteLogin("连接超数!");return;
		}
	CDatabase *db=new CDatabase;
	if(AddConn(db, "db")==0)
	{
		return;
	}
	g_pDB[g_nDBCount]=db;
	CString dbname;
	for(int i=0; i<yeararray.GetSize (); i++)
	{
		dbname.Format ("%d", yeararray.ElementAt (i));
		CDatabase *db=new CDatabase;
		AddConn(db, dbname);
		g_pHistoryDBarray[g_nDBCount].Add (db);
	}
	g_nDBCount++;
	}
	catch(...)
	{		
		WriteLogin("AddOneConn error");
	}
}

void GetOneConn(CDatabase **m_pdb, CArray<CDatabase*,CDatabase*>*m_dbarray, CConnectThread *pThread)
{
	MyLock lock("GetOneConnxiao");
ll:	for(int i=0; i<200; i++)
	{
		if(g_pDB[i]!=NULL && g_pThreadPt[i]==NULL)
		{
			*m_pdb=g_pDB[i];
			m_dbarray->Copy(g_pHistoryDBarray[i]);
			g_pThreadPt[i]=pThread;
			return;
		}
	}
   	if(g_nDBCount>=200)
	{
		WriteLogin("连接超数2!");
		*m_pdb=&g_db;
		m_dbarray->Copy(dbarray);
		return;
	}
//	g_pMainWnd->AddOneConn();
	::Sleep(1000);
	goto ll;
}

void CDBServerDlg::CheckConnCount()
{
	int count=0;
 	for(int i=0; i<200; i++)
	{
		if(g_pDB[i]!=NULL && g_pThreadPt[i]==NULL)
		{
			count++;
			if(count>9)return;
		}
	}
	AddOneConn();
}
//delete from singleincome