1445 lines
53 KiB
C++
Executable File
1445 lines
53 KiB
C++
Executable File
//Il sorgente va scritto in notazione ungherese.
|
||
//Le variabili seguono la seguente regola: 'acronimo tipo'+'nome variabile cammellata'
|
||
//Es. wxArrayString 'as' + 'AcceptRefuse' -> asAcceptRefuse
|
||
#include "wxinc.h"
|
||
|
||
|
||
#include <wx/protocol/http.h>
|
||
#include <wx/snglinst.h>
|
||
|
||
#include "key.h"
|
||
#include "wizard.h"
|
||
#include "utils.h"
|
||
|
||
#include <shlobj.h>
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// CampoFrame
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class CampoFrame : public wxFrame
|
||
{
|
||
protected:
|
||
DECLARE_EVENT_TABLE();
|
||
virtual void OnErase(wxEraseEvent& e);
|
||
public:
|
||
CampoFrame();
|
||
};
|
||
|
||
BEGIN_EVENT_TABLE(CampoFrame, wxFrame)
|
||
EVT_ERASE_BACKGROUND(CampoFrame::OnErase)
|
||
END_EVENT_TABLE()
|
||
|
||
void CampoFrame::OnErase(wxEraseEvent& e)
|
||
{
|
||
//preparazione background
|
||
wxDC& dc = *e.GetDC();
|
||
const wxRect rect = GetClientSize();
|
||
wxColour c0 = wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT);
|
||
wxColour c1 = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
|
||
wxColour c2 = wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW);
|
||
|
||
wxRect rect1 = rect; rect1.SetBottom(rect.GetBottom() / 2);
|
||
dc.GradientFillLinear(rect1, c0, c1, wxSOUTH);
|
||
|
||
wxRect rect2 = rect; rect2.SetTop(rect1.GetBottom());
|
||
dc.GradientFillLinear(rect2, c1, c2, wxDOWN);
|
||
|
||
int nHeight = rect.GetHeight()/14;
|
||
wxFont* pFont = wxTheFontList->FindOrCreateFont(nHeight, wxFONTFAMILY_SWISS, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_BOLD);
|
||
dc.SetFont(*pFont);
|
||
|
||
int w = 0, h = 0; dc.GetTextExtent(RESELLER, &w, &h);
|
||
while (w > rect.width)
|
||
{
|
||
nHeight = nHeight * rect.width / w;
|
||
pFont = wxTheFontList->FindOrCreateFont(nHeight, wxFONTFAMILY_SWISS, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_BOLD);
|
||
dc.SetFont(*pFont);
|
||
dc.GetTextExtent(RESELLER, &w, &h);
|
||
}
|
||
|
||
const int k = nHeight / 16 + 1;
|
||
|
||
dc.SetBackgroundMode(wxTRANSPARENT);
|
||
dc.SetTextForeground(c2);
|
||
dc.DrawText(RESELLER, rect.GetRight()-w-k/2, rect.GetHeight()-h-k/2);
|
||
dc.SetTextForeground(c1);
|
||
dc.DrawText(RESELLER, rect.GetRight()-w-k, rect.GetHeight()-h-k);
|
||
|
||
dc.SetTextForeground(c2);
|
||
dc.DrawText(PRODUCT, k, k);
|
||
dc.SetTextForeground(c1);
|
||
dc.DrawText(PRODUCT, k/2, k/2);
|
||
|
||
wxFont* pSmallFont = wxTheFontList->FindOrCreateFont(nHeight/6, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_LIGHT);
|
||
dc.SetFont(*pSmallFont);
|
||
const wxString strTime = __TIMESTAMP__;
|
||
dc.GetTextExtent(strTime, &w, &h);
|
||
dc.SetTextForeground(c2);
|
||
dc.DrawText(strTime, rect.GetRight()-w, 0);
|
||
|
||
}
|
||
|
||
CampoFrame::CampoFrame() : wxFrame(NULL, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0)
|
||
{
|
||
ShowFullScreen(true);
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// CampoSetup
|
||
///////////////////////////////////////////////////////////
|
||
//classe principale, ovvero applicazione
|
||
class CampoSetup : public wxApp
|
||
{
|
||
CampoFrame* m_pMainFrame;
|
||
wxLocale m_locale;
|
||
wxString m_strSetupPath;
|
||
bool m_bLurchWasRunning;
|
||
|
||
CampoWizard* m_pWizard;
|
||
|
||
private:
|
||
bool WriteRegistryKey(HKEY hBaseKey, const wxString strKey, const wxString& strValue) const;
|
||
wxString ReadRegistryKey(HKEY hBaseKey, const wxString strKey) const;
|
||
wxString GetFolderPath(unsigned int uPathID) const;
|
||
|
||
protected:
|
||
DECLARE_EVENT_TABLE()
|
||
|
||
//metodi principali dell'applicazione
|
||
void OnTimer(wxTimerEvent& e);
|
||
void DiskUpdate();
|
||
void InternetUpdate();
|
||
void ClientUpdate();
|
||
void NormalSetup();
|
||
bool SystemRunning(const wxString& strAppName, wxString strMsg) const;
|
||
int LurchRunning() const;
|
||
bool CampoIsRunning() const;
|
||
|
||
//metodi di interfaccia con Windows
|
||
bool CreateIcon(unsigned int csidl, const wxFileName& strExeFile, const wxString& strLinkName) const;
|
||
void AssociateExtension(const wxFileName& strExeFile, const wxString strExt);
|
||
//...per i servers
|
||
bool CreateAutostartLurch(const LurchMode iSrvAutostartMode, const wxString& strPath);
|
||
bool StopLurch() const;
|
||
bool StartLurch(const wxString& strPrgLocPath) const;
|
||
bool LurchWasRunning() const { return m_bLurchWasRunning; }
|
||
|
||
//metodi di interfaccia con il registry di Windows
|
||
wxString ReadRootRegistryKey(const wxString strKey) const;
|
||
wxString ReadLocalMachineRegistryKey(const wxString strKey) const;
|
||
bool WriteRootRegistryKey(const wxString strKey, const wxString& strValue) const;
|
||
bool WriteLocalMachineRegistryKey(const wxString strKey, const wxString& strValue) const;
|
||
|
||
//metodi di utility per i vari modi di aggiornamento
|
||
const wxString GetSourceDir(const wxString strDirName) const;
|
||
const wxString& GetSetupDir() const { return m_strSetupPath; }
|
||
void EmptyOutDir(const wxString& strDir) const;
|
||
bool UnzipModule(const wxString& strPrgLocPath, const wxString& strSrc, const wxString& strModule) const;
|
||
void CopyDir(const wxString& strSourceDir, const wxString& strDestDir) const;
|
||
bool CopyFilesAndDirs(const wxString& FilesListI, wxString strFileCurr, const bool bIni) const;
|
||
void UpdateInstallIni(const wxString strSourcePath, const wxString strDestPath, const wxString& strModule) const;
|
||
bool HTTPGet(const wxString& strLocalPath, const wxString& strWebPath) const;
|
||
|
||
//metodi di aggiornamento non standard (client, da disco e via web con installazione moduli)
|
||
int ClientUpdateModule(const wxString& strLocalPath, const wxString& strRemotePath, const wxString strModule) const;
|
||
bool DiskUpdateModule(const wxString& strLocalPath, const wxString& strWebPath, const wxString strModule) const;
|
||
bool InternetUpdateModule(const wxString& strLocalPath, const wxString& strWebPath, const wxString strModule) const;
|
||
|
||
public:
|
||
virtual bool OnInit();
|
||
};
|
||
|
||
IMPLEMENT_APP(CampoSetup)
|
||
|
||
BEGIN_EVENT_TABLE(CampoSetup, wxApp)
|
||
EVT_TIMER(883, OnTimer)
|
||
END_EVENT_TABLE()
|
||
|
||
//----------------------------------------------------------------
|
||
// Metodi di lettura/scrittura registry di Windows (fantastici!)
|
||
//----------------------------------------------------------------
|
||
wxString CampoSetup::ReadRegistryKey(HKEY hBaseKey, const wxString strKey) const
|
||
{
|
||
wxString strValue;
|
||
HKEY hKey = NULL;
|
||
wxString strPath, strName;
|
||
wxFileName::SplitPath(strKey, &strPath, &strName, NULL);
|
||
|
||
bool ok = ::RegOpenKeyEx(hBaseKey, strPath, 0, KEY_READ, &hKey) == ERROR_SUCCESS;
|
||
if (ok)
|
||
{
|
||
BYTE buff[512];
|
||
DWORD type = REG_SZ;
|
||
DWORD dw = sizeof(buff);
|
||
ok = ::RegQueryValueEx(hKey, strName, NULL, &type, buff, &dw) == ERROR_SUCCESS;
|
||
if (ok)
|
||
strValue = buff;
|
||
::RegCloseKey(hKey);
|
||
}
|
||
return strValue;
|
||
}
|
||
|
||
wxString CampoSetup::ReadRootRegistryKey(const wxString strKey) const
|
||
{
|
||
return ReadRegistryKey(HKEY_CLASSES_ROOT, strKey);
|
||
}
|
||
|
||
wxString CampoSetup::ReadLocalMachineRegistryKey(const wxString strKey) const
|
||
{
|
||
return ReadRegistryKey(HKEY_LOCAL_MACHINE, strKey);
|
||
}
|
||
|
||
bool CampoSetup::WriteRegistryKey(HKEY hBaseKey, const wxString strKey, const wxString& strValue) const
|
||
{
|
||
HKEY hKey = NULL;
|
||
DWORD dw = 0;
|
||
//splitta la stringa in path e valore
|
||
wxString strPath, strName;
|
||
wxFileName::SplitPath(strKey, &strPath, &strName, NULL);
|
||
|
||
bool ok = ::RegCreateKeyEx(hBaseKey, strPath, 0, REG_NONE,
|
||
REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL, &hKey, &dw) == ERROR_SUCCESS;
|
||
if (ok)
|
||
{
|
||
ok = ::RegSetValueEx(hKey, strName, 0, REG_SZ,
|
||
(BYTE*)(const wxChar*)strValue, DWORD(2*strValue.Len()+2)) == ERROR_SUCCESS;
|
||
::RegCloseKey(hKey);
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
bool CampoSetup::WriteRootRegistryKey(const wxString strKey, const wxString& strValue) const
|
||
{
|
||
return WriteRegistryKey(HKEY_CLASSES_ROOT, strKey, strValue);
|
||
}
|
||
|
||
bool CampoSetup::WriteLocalMachineRegistryKey(const wxString strKey, const wxString& strValue) const
|
||
{
|
||
return WriteRegistryKey(HKEY_LOCAL_MACHINE, strKey, strValue);
|
||
}
|
||
|
||
//----------------------------------
|
||
// Metodi di interfaccia con Windows
|
||
//----------------------------------
|
||
wxString CampoSetup::GetFolderPath(unsigned int uPathID) const
|
||
{
|
||
TCHAR szPath[MAX_PATH] = wxT("");
|
||
HRESULT hres = ::SHGetFolderPath(NULL, uPathID, NULL, SHGFP_TYPE_CURRENT, szPath);
|
||
return szPath;
|
||
}
|
||
|
||
|
||
void CampoSetup::AssociateExtension(const wxFileName& strExeFile, const wxString strExt)
|
||
{
|
||
// Register icon and application
|
||
WriteRootRegistryKey(strExt, APPNAME);
|
||
|
||
wxString str = strExeFile.GetFullPath(); str += wxT(",0");
|
||
WriteRootRegistryKey(APPNAME + wxT("\\DefaultIcon"), str);
|
||
|
||
str = strExeFile.GetFullPath(); str += wxT(" \"%1\"");
|
||
WriteRootRegistryKey(APPNAME + wxT("\\shell\\open\\command"), str);
|
||
}
|
||
|
||
bool CampoSetup::CreateIcon(unsigned int csidl, const wxFileName& strExeFile, const wxString& strLinkName) const
|
||
{
|
||
//csidl = CSIDL_COMMON_DESKTOPDIRECTORY = desktop
|
||
//csidl = CSIDL_COMMON_STARTUP = all users esecuzione automatica
|
||
const wxString strDesktopPath = GetFolderPath(csidl);
|
||
bool ok = wxDirExists(strDesktopPath);
|
||
if (ok)
|
||
{
|
||
::CoInitialize(NULL);
|
||
|
||
// Get a pointer to the IShellLink interface.
|
||
IShellLink* psl = NULL;
|
||
HRESULT hres = ::CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl);
|
||
if (SUCCEEDED(hres))
|
||
{
|
||
// Set the path to the shortcut target and add the description.
|
||
psl->SetPath(strExeFile.GetFullPath());
|
||
psl->SetWorkingDirectory(strExeFile.GetPath());
|
||
psl->SetDescription(APPNAME);
|
||
|
||
//sceglie l'icona da quelle possibili legate al .exe in base al tipo di installazione
|
||
const InstallationType uInstallationType = m_pWizard->GetInstallationType();
|
||
|
||
//anche l'icona deve essere scelta in base al reseller
|
||
wxString strIcon = Icon();
|
||
//path completo del file icona, in modo da legarlo al link sul desktop;comincia con il path di Campo
|
||
wxString strPath = m_pWizard->GetPrgLocPath();
|
||
|
||
if (!strIcon.IsEmpty())
|
||
{
|
||
strPath += "/setup/"; //se esiste l'icona del reseller sta in setup
|
||
}
|
||
else
|
||
{
|
||
strPath += "/res/"; //se non trova l'icona del reseller prende quella standard in res
|
||
}
|
||
|
||
const int nPos = strIcon.Len() - 4;
|
||
switch (uInstallationType)
|
||
{
|
||
case it_server: strIcon.insert(nPos, "Srv"); break;
|
||
case it_client: strIcon.insert(nPos, "Cln"); break;
|
||
default: break;
|
||
}
|
||
|
||
strPath << strIcon;
|
||
psl->SetIconLocation(strPath, 0);
|
||
|
||
// Query IShellLink for the IPersistFile interface for saving the
|
||
// shortcut in persistent storage.
|
||
IPersistFile* ppf;
|
||
hres = psl->QueryInterface(IID_IPersistFile, (void**)&ppf);
|
||
|
||
if (SUCCEEDED(hres))
|
||
{
|
||
wxFileName fnLnk;
|
||
wxString strName = strLinkName + ".lnk";
|
||
fnLnk.Assign(strDesktopPath, strName);
|
||
|
||
// Save the link by calling IPersistFile::Save.
|
||
wxString strPath = fnLnk.GetFullPath();
|
||
wchar_t buff[_MAX_PATH];
|
||
wxConvLibc.ToWChar(buff, _MAX_PATH, strPath);
|
||
hres = ppf->Save(buff, true);
|
||
ppf->Release();
|
||
}
|
||
psl->Release();
|
||
|
||
if (FAILED(hres))
|
||
ok = ErrorBox(wxT("Impossibile creare l'icona del collegamento: eseguire l'installazione come amministratore"));
|
||
}
|
||
CoUninitialize();
|
||
}
|
||
|
||
return ok;
|
||
}
|
||
|
||
|
||
//-------------------------------------------
|
||
// ..per i servers di Campo
|
||
//-------------------------------------------
|
||
bool CampoSetup::StopLurch() const
|
||
{
|
||
const wxString strExecService = "Servers/SSAservice -stop";
|
||
return wxExecute(strExecService, wxEXEC_SYNC) > 0;
|
||
}
|
||
|
||
bool CampoSetup::StartLurch(const wxString& strPrgLocPath) const
|
||
{
|
||
const wxString strExecService = strPrgLocPath + "Servers/SSAservice -start";
|
||
return wxExecute(strExecService) > 0;
|
||
}
|
||
|
||
bool CampoSetup::CreateAutostartLurch(const LurchMode iSrvAutostartMode, const wxString& strPath)
|
||
{
|
||
if (LurchRunning())
|
||
StopLurch();
|
||
|
||
const wxString strCreateService = "Servers/SSAservice -install";
|
||
return wxExecute(strCreateService) > 0;
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------
|
||
// Metodi di utility per i vari tipi di aggiornamento
|
||
//----------------------------------------------------------------
|
||
static int PatchCompare(const wxString& first, const wxString& second)
|
||
{
|
||
const wxFileName fn1(first);
|
||
const wxFileName fn2(second);
|
||
const wxString strName1 = fn1.GetName().Lower();
|
||
const wxString strName2 = fn2.GetName().Lower();
|
||
if (strName1.Mid(2, 4) == "inst")
|
||
return -1;
|
||
if (strName2.Mid(2, 4) == "inst")
|
||
return 1;
|
||
|
||
return strName1.CompareTo(strName2);
|
||
}
|
||
|
||
const wxString CampoSetup::GetSourceDir(const wxString strDirName) const
|
||
{
|
||
wxFileName strSourcePath(GetSetupDir(), "pippo.txt");
|
||
strSourcePath.AppendDir("..");
|
||
strSourcePath.AppendDir("..");
|
||
strSourcePath.AppendDir(strDirName);
|
||
strSourcePath.MakeAbsolute();
|
||
const wxString strSrc = strSourcePath.GetPath();
|
||
return strSrc;
|
||
}
|
||
|
||
//metodo per aggiornare il modulo SY in install.ini
|
||
void CampoSetup::UpdateInstallIni(const wxString strSourcePath, const wxString strDestPath, const wxString& strModule) const
|
||
{
|
||
for (int j = 0; j < 2; j++)
|
||
{
|
||
wxString strParagraph = strModule;
|
||
if (j > 0)
|
||
strParagraph << j;
|
||
CampoIniFile InstallIniSource(strSourcePath, strParagraph);
|
||
CampoIniFile InstallIniDest(strDestPath, strParagraph);
|
||
|
||
wxString strWrk;
|
||
long nIndex;
|
||
for (bool ok = InstallIniSource.GetFirstEntry(strWrk, nIndex); ok; ok = InstallIniSource.GetNextEntry(strWrk, nIndex))
|
||
{
|
||
InstallIniDest.Set(strWrk, InstallIniSource.Get(strWrk));
|
||
}
|
||
}
|
||
}
|
||
|
||
bool CampoSetup::UnzipModule(const wxString& strPrgLocPath, const wxString& strSrc, const wxString& strModule) const
|
||
{
|
||
bool ok = false;
|
||
wxArrayString asFilesList;
|
||
size_t uFilesToCopy = 0;
|
||
//..contando anche quanti sono e memorizzandoli in un array asFileList
|
||
if(wxDir::Exists(strSrc))
|
||
{
|
||
uFilesToCopy = wxDir::GetAllFiles(strSrc, &asFilesList, strModule+"*.zip");
|
||
if (uFilesToCopy > 0)
|
||
{
|
||
//ordina le patch per numero crescente ma mette davanti a tutte il pacco (sysinst1)
|
||
asFilesList.Sort(PatchCompare);
|
||
for (size_t i = 0; i < uFilesToCopy; i++)
|
||
UnzipFile(asFilesList[i] , strPrgLocPath);
|
||
|
||
//aggiorna l'install.ini in base al numero di patch e versione dell'ultimo file zip di sistema
|
||
//ci vuole un giro allucinogeno per trasformare il .zip in .ini e togliere quel cazzo di 1 in fondo
|
||
wxFileName strLastFile(asFilesList[uFilesToCopy - 1]); //zip con path completo
|
||
wxString strWrk = strLastFile.GetName();
|
||
strWrk.Truncate(strWrk.Len() - 1);
|
||
strLastFile.SetName(strWrk);
|
||
strLastFile.SetExt("ini");
|
||
strWrk = strLastFile.GetFullPath();
|
||
|
||
//adesso che ha trovato quello sporco ultimo .ini prende versione e patch e le copia nell'install.ini..
|
||
//..nella dir dei programmi; lo fa paragrafo x paragrafo ([sy],[sy1]..)
|
||
//potrebbe sembrare assurdo un for, ma e' per futuri sottomoduli con numero > 1
|
||
UpdateInstallIni(strWrk, strPrgLocPath + "/install.ini", strModule);
|
||
}
|
||
}
|
||
|
||
//Adesso puo' far ripartire il server di chiavi
|
||
if (strModule == "sr" && LurchWasRunning())
|
||
StartLurch(strPrgLocPath);
|
||
|
||
return uFilesToCopy > 0;
|
||
}
|
||
|
||
bool CampoSetup::CopyFilesAndDirs(const wxString& FilesListI, wxString strFileCurr, const bool bIni) const
|
||
{
|
||
bool ok = true;
|
||
|
||
//i files .ini vanno trattati con i guanti (se esistono gi<67> non vanno copiati!!!)
|
||
//parte da eseguire solo in caso sia indicata la trattazione degli ini (bIni true)
|
||
if (bIni)
|
||
{
|
||
strFileCurr.MakeLower(); //minuscolizzazione di sicurezza
|
||
const wxFileName strFileName(strFileCurr);
|
||
if (strFileName.GetExt() == "ini")
|
||
{
|
||
const wxString strName = strFileName.GetName();
|
||
//campo.ini e install.ini vanno lasciati stare se esistono (aggiornamento)!!!
|
||
if ((strName == "campo" || strName == "install") && strFileName.FileExists())
|
||
ok = false;
|
||
}
|
||
}
|
||
|
||
if (ok)
|
||
ok = CopiaFile(FilesListI, strFileCurr);
|
||
|
||
return ok;
|
||
}
|
||
|
||
//metodo per copiare una directory e tutti i files che contiene
|
||
void CampoSetup::CopyDir(const wxString& strSourceDir, const wxString& strDestDir) const
|
||
{
|
||
if (wxDir::Exists(strSourceDir))
|
||
{
|
||
wxArrayString asFilesList;
|
||
const size_t uFilesToCopy = wxDir::GetAllFiles(strSourceDir, &asFilesList, "*.*");
|
||
const size_t uFrom = strSourceDir.Len();
|
||
for (size_t i = 0; i < uFilesToCopy; i++)
|
||
{
|
||
wxString strFileDest = strDestDir + asFilesList[i].Mid(uFrom);
|
||
CopiaFile(asFilesList[i], strFileDest);
|
||
}
|
||
}
|
||
}
|
||
|
||
//metodo per accoppare tutti i files di una directory
|
||
void CampoSetup::EmptyOutDir(const wxString& strDir) const
|
||
{
|
||
if (wxFileName::DirExists(strDir))
|
||
{
|
||
wxArrayString asFilesList;
|
||
const size_t uFilesToKill = wxDir::GetAllFiles(strDir, &asFilesList, "*.*");
|
||
for (size_t i = 0; i < uFilesToKill; i++)
|
||
::wxRemoveFile(asFilesList[i]);
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------
|
||
// METODI BASSO LIVELLO PER AGGIORNAMENTI NON STANDARD
|
||
//-----------------------------------------------------
|
||
//----------------------------
|
||
// 1) AGGIORNAMENTO CLIENT
|
||
//----------------------------
|
||
//Aggiornatore client. Copia i files del programma da una directory remota su un server campo nella directory...
|
||
//...locale di campo
|
||
int CampoSetup::ClientUpdateModule(const wxString& strLocalPath, const wxString& strRemotePath, const wxString strModule) const
|
||
{
|
||
int nLocVer, nLocPatch, nRemVer, nRemPatch;
|
||
{
|
||
CampoIniFile iniLocalInstall(strLocalPath + "/install.ini", strModule);
|
||
nLocVer = iniLocalInstall.GetInt("Versione");
|
||
nLocPatch = iniLocalInstall.GetInt("Patch");
|
||
|
||
CampoIniFile iniRemoteInstall(strRemotePath + "/install.ini", strModule);
|
||
nRemVer = iniRemoteInstall.GetInt("Versione");
|
||
nRemPatch = iniRemoteInstall.GetInt("Patch");
|
||
}
|
||
int cmp = nLocVer - nRemVer;
|
||
if (cmp == 0)
|
||
cmp = nLocPatch - nRemPatch;
|
||
|
||
//il client e' piu' indietro e quindi va aggiornato!
|
||
if (cmp < 0)
|
||
{
|
||
bool bOk = true;
|
||
|
||
CampoProgressDialog pi("Aggiornamento elenco files dal server...", 100, m_pWizard);
|
||
|
||
wxArrayString asGroups;
|
||
{
|
||
wxString strGroup;
|
||
long nIndex;
|
||
CampoIniFile iniRemoteInstall(strRemotePath + "/install.ini", "");
|
||
for (bool ok = iniRemoteInstall.GetFirstGroup(strGroup, nIndex); ok; ok = iniRemoteInstall.GetNextGroup(strGroup, nIndex))
|
||
{
|
||
if(strGroup.Len() > 2 && strGroup.StartsWith(strModule))
|
||
asGroups.Add(strGroup);
|
||
}
|
||
}
|
||
|
||
//controlla tutti i sottomoduli del modulo [sy1],[sy2]...
|
||
for (size_t i = 0; i < asGroups.GetCount() && bOk; i++)
|
||
{
|
||
const wxString& strParagraph = asGroups[i];
|
||
CampoIniFile iniRemoteInstallModule(strRemotePath + "/install.ini", strParagraph);
|
||
|
||
//install.ini locale che deve essere aggiornato durante la copia dei files!
|
||
CampoIniFile iniLocalInstall(strLocalPath + "/install.ini", strParagraph);
|
||
|
||
//ogni file dell'elenco del sottomodulo corrente va copiato
|
||
for (int j = 0;; j++)
|
||
{
|
||
pi.Pulse(); //magica barra modello supercar!
|
||
|
||
const wxString strVarName = wxString::Format("File(%d)", j);
|
||
wxString strCurrFile = iniRemoteInstallModule.Get(strVarName);
|
||
if (strCurrFile.IsEmpty())
|
||
break;
|
||
|
||
strCurrFile = strCurrFile.BeforeFirst('|');
|
||
|
||
const wxString strSrcPath = strRemotePath + "/" + strCurrFile;
|
||
const wxString strDstPath = strLocalPath + "/" + strCurrFile;
|
||
|
||
//copia il file remoto di origine sul file locale di destinazione (overwrite=true di default)
|
||
if (!CopiaFile(strSrcPath, strDstPath))
|
||
{
|
||
wxString strError;
|
||
strError += "\nAssicurarsi che il client locale di ";
|
||
strError += APPNAME;
|
||
strError += " non sia in funzione.\n";
|
||
strError += "Assicurarsi che il server di ";
|
||
strError += APPNAME;
|
||
strError += " sia in funzione e raggiungibile in rete.\n";
|
||
strError += "Aggiornamento interrotto!";
|
||
ErrorBox(strError);
|
||
bOk = false;
|
||
break;
|
||
}
|
||
|
||
//se ci sono zip deve scompattarli (per ora esiste solo res.zip)
|
||
if (strCurrFile.EndsWith("res.zip")) // Non confonderti con dninst.zip
|
||
{
|
||
UnzipFile(strDstPath, strLocalPath + "/res");
|
||
}
|
||
|
||
//se riesce la copia del file aggiorna l'install.ini sul file (se non lo facesse non comparirebbero...
|
||
//...eventuali nuovi files
|
||
iniLocalInstall.Set(strVarName, strCurrFile);
|
||
|
||
} //for(int j...
|
||
|
||
//una volta termiata la copia dei files del sottmodulo[i] scatta l'aggiornamento dell'install.ini locale...
|
||
//...al livello versione/patch appena copiate sempre del sottomodulo[i]
|
||
iniLocalInstall.Set("Versione", nRemVer);
|
||
iniLocalInstall.Set("Patch", nRemPatch);
|
||
|
||
} //for(int i...
|
||
|
||
//una volta termiata la copia dei files dell'intero modulo scatta l'aggiornamento dell'install.ini locale al..
|
||
//..livello versione/patch appena copiate
|
||
CampoIniFile iniLocalInstall(strLocalPath + "/install.ini", strModule);
|
||
iniLocalInstall.Set("Versione", nRemVer);
|
||
iniLocalInstall.Set("Patch", nRemPatch);
|
||
|
||
} //if(cmp<0...
|
||
|
||
return cmp;
|
||
}
|
||
|
||
|
||
//----------------------------
|
||
// 2) AGGIORNAMENTO DA DISCO
|
||
//----------------------------
|
||
//Aggiornatore da disco. Copia i files delle patch da una directory su disco in una directory di appoggio...
|
||
//...temporanea dove esegue lo scompattamento con destinazione la directory locale
|
||
bool CampoSetup::DiskUpdateModule(const wxString& strLocalPath, const wxString& strDiskPath, const wxString strModule) const
|
||
{
|
||
//puo' chiamare direttamente il metodo che scompatta tutte le patch del modulo a partire dal pacco iniziale...
|
||
//...fino all'ultima;il metodo le ordina gi<67> in modo crescente di numero d'ordine
|
||
return UnzipModule(strLocalPath, strDiskPath, strModule);
|
||
}
|
||
|
||
//-------------------------------
|
||
// 3) AGGIORNAMENTO DA INTERNET
|
||
//-------------------------------
|
||
bool CampoSetup::HTTPGet(const wxString& strLocalPath, const wxString& strWebSite) const
|
||
{
|
||
wxString strWebPath = strWebSite;
|
||
if (strWebPath.StartsWith("http://"))
|
||
strWebPath.Remove(0, 7);
|
||
int nSlash = strWebPath.First('/');
|
||
wxString strServer = strWebPath.Left(nSlash);
|
||
wxString strPath = strWebPath.Mid(nSlash);
|
||
|
||
wxHTTP http;
|
||
//connessione al server web con le patch
|
||
if (http.Connect(strServer))
|
||
{
|
||
wxInputStream* pStream = http.GetInputStream(strPath);
|
||
if (pStream != NULL)
|
||
{
|
||
//compila un file di testo temporaneo con l'elenco dei files che trova sul server
|
||
wxFileOutputStream fos(strLocalPath);
|
||
fos.Write(*pStream);
|
||
delete pStream;
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//Aggiornatore via web. Copia i files delle patch da una directory web remota in una directory di appoggio...
|
||
//...temporanea dove esegue lo scompattamento con destinazione la directory locale
|
||
bool CampoSetup::InternetUpdateModule(const wxString& strLocalPath, const wxString& strWebPath, const wxString strModule) const
|
||
{
|
||
bool ok = false;
|
||
int nLocVer = 20911000, nLocPatch = 100; // Fingo la versione 10.0
|
||
{
|
||
CampoIniFile iniLocalInstall(strLocalPath + "/install.ini", strModule);
|
||
nLocVer = iniLocalInstall.GetInt("Versione");
|
||
nLocPatch = iniLocalInstall.GetInt("Patch");
|
||
}
|
||
|
||
//Svuota,elimina e ricrea una directory temporanea di appoggio ove mettere i files delle patch da scompattare
|
||
//E' necessaria questa operazione per non trovarsi ancora files di vecchie patch parcheggiati nella dir!
|
||
const wxString strTempDir = wxFileName::GetTempDir() + "/setup/";
|
||
if (wxDir::Exists(strTempDir))
|
||
{
|
||
EmptyOutDir(strTempDir); //deve svuotare la directory dai files per poterla eliminare!!!
|
||
::wxRmdir(strTempDir); //elimina la dir adesso vuota
|
||
}
|
||
CheckAndMakeDir(strTempDir, wxEmptyString); //la ricrea con i permessi dell'utente windows corrente!!
|
||
|
||
const wxString strTempFile = strTempDir + "httpdir.txt";
|
||
if (HTTPGet(strTempFile, strWebPath))
|
||
{
|
||
//partendo dal file temporaneo ne compila un secondo con i soli nomi dei file validi da scaricare
|
||
//i criteri di selezione sono il nome del modulo ed il livello patch
|
||
wxTextFile tfFilesList;
|
||
if (tfFilesList.Open((strTempFile)))
|
||
{
|
||
CampoProgressDialog pi("Aggiornamento elenco files dal server...", (int)tfFilesList.GetLineCount(), m_pWizard);
|
||
for (wxString strWrk = tfFilesList.GetFirstLine(); !tfFilesList.Eof(); strWrk = tfFilesList.GetNextLine())
|
||
{
|
||
int nPos = strWrk.Find("href");
|
||
if (nPos > 0)
|
||
{
|
||
wxString strHref = strWrk.Mid(nPos + 5, 16);
|
||
strHref = strHref.AfterFirst('"');
|
||
strHref = strHref.BeforeLast('"');
|
||
|
||
if (!pi.Update((int)tfFilesList.GetCurrentLine(), strHref))
|
||
break;
|
||
|
||
//lavora solo con i files del modulo in questione
|
||
if (strHref.StartsWith(strModule))
|
||
{
|
||
const wxString strExt = strHref.Right(4).Lower();
|
||
if (strExt!=".ini" && strExt!=".zip")
|
||
continue;
|
||
|
||
const wxString strPatch = strHref.Mid(2, 4).Lower();
|
||
// 1) e' un pacco
|
||
//se e' un pacco devo sapere se e' piu' recente della installazione corrente (potrebbe essere un pacco nuovo..
|
||
//..ricompattato) oppure se e' piu' vecchio e non va toccato (e' ad esempio il pacco originale)
|
||
if (strPatch == "inst")
|
||
{
|
||
if (strExt == ".ini") //operazioni sull'ini x sapere versione e patch
|
||
{
|
||
HTTPGet(strTempDir+strHref, strWebPath+strHref);
|
||
CampoIniFile iniInst(strTempDir+strHref, strModule);
|
||
const int nRemoteVer = iniInst.GetInt("Versione");
|
||
const int nRemotePatch = iniInst.GetInt("Patch");
|
||
|
||
//se deve aggiornarsi con il pacco scarica pure lo zip cosi' e' a posto
|
||
if ((nRemoteVer > nLocVer) || ((nRemoteVer == nLocVer) && (nRemotePatch > nLocPatch)))
|
||
{
|
||
const int nDot = strHref.Find('.', true);
|
||
strHref = strHref.Left(nDot) + "1.zip";
|
||
HTTPGet(strTempDir+strHref, strWebPath+strHref);
|
||
}
|
||
else //se non deve aggiornarsi elimina l'ini in modo da non avere una mezza patch che farebbe incazzare l'unzipper
|
||
wxRemoveFile(strTempDir+strHref);
|
||
} //if(strHref.EndsWith("ini")...
|
||
} //if(strPatch == "inst")...
|
||
// 2) e' una patch
|
||
else //se invece e' una normale patch... else di if(strPatch=="inst"..
|
||
{
|
||
//controlla che sia pi<70> avanti del suo livello patch e che sia un file utile (servono solo .ini e .zip)
|
||
if (atoi(strPatch) > nLocPatch)
|
||
HTTPGet(strTempDir+strHref, strWebPath+strHref);
|
||
}
|
||
} //if(strHref.StartsWith(strModule))...
|
||
} //if(nPos>0)...
|
||
} //for(wxString strWrk = tf...
|
||
//chiude il file temporaneo
|
||
tfFilesList.Close();
|
||
} //if(tfFilesList...
|
||
|
||
//scompatta le patch di sistema e aggiorna l'install.ini locale
|
||
ok = UnzipModule(strLocalPath, strTempDir, strModule);
|
||
} //if(HTTPGet(...
|
||
return ok;
|
||
}
|
||
|
||
//-----------------------------------------------------
|
||
// METODI ALTO LIVELLO PER AGGIORNAMENTI NON STANDARD
|
||
//-----------------------------------------------------
|
||
//---------------------------------------------------------------
|
||
// 1) metodo per l'aggiornamento dei client di rete in automatico
|
||
//---------------------------------------------------------------
|
||
void CampoSetup::ClientUpdate()
|
||
{
|
||
wxFileName fn(GetSetupDir());
|
||
fn.AppendDir("..");
|
||
fn.MakeAbsolute();
|
||
fn.SetFullName("install.ini");
|
||
const wxString strLocalPath = fn.GetPath();
|
||
|
||
wxString strRemotePath;
|
||
{
|
||
CampoIniFile iniLocalInstall(fn.GetFullPath(), "Main");
|
||
strRemotePath = iniLocalInstall.Get("DiskPath");
|
||
}
|
||
|
||
ClientUpdateModule(strLocalPath, strRemotePath, "sy");
|
||
|
||
wxSetWorkingDirectory(strLocalPath);
|
||
wxExecute("ba1 -6 /uADMIN");
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------------------------
|
||
// 2) metodo per l'aggiornamento da disco attraverso il menu di Manutenzione/Installazione moduli
|
||
//-----------------------------------------------------------------------------------------------
|
||
void CampoSetup::DiskUpdate()
|
||
{
|
||
wxFileName fn(GetSetupDir());
|
||
fn.AppendDir("..");
|
||
fn.MakeAbsolute();
|
||
fn.SetFullName("install.ini");
|
||
const wxString strLocalPath = fn.GetPath();
|
||
|
||
wxString strRemotePath;
|
||
{
|
||
CampoIniFile iniLocalInstall(fn.GetFullPath(), "Main");
|
||
strRemotePath = iniLocalInstall.Get("DiskPath");
|
||
}
|
||
|
||
//aggiornamento dei moduli SY ed SR da disco
|
||
//il modulo SY va aggiornato comunque
|
||
#ifndef NDEBUG
|
||
strRemotePath = "c:/campo12/cd/program/";
|
||
DiskUpdateModule(strLocalPath, strRemotePath, "sc");
|
||
#else
|
||
DiskUpdateModule(strLocalPath, strRemotePath, "sy");
|
||
//il modulo SR va aggiornato solo se usato (si sta aggiornando il cpu con il gestore delle chiavi)
|
||
if (m_bLurchWasRunning)
|
||
DiskUpdateModule(strLocalPath, strRemotePath, "sr");
|
||
#endif
|
||
|
||
wxSetWorkingDirectory(strLocalPath);
|
||
wxExecute("ba1 -6 /uADMIN");
|
||
}
|
||
|
||
//----------------------------------------------------------------------------------------
|
||
// 3) metodo per l'aggiornamento via internet attraverso Manutenzione/Installazione moduli
|
||
//----------------------------------------------------------------------------------------
|
||
void CampoSetup::InternetUpdate()
|
||
{
|
||
//install.ini locale dove setup.exe e' in esecuzione
|
||
wxFileName fn(GetSetupDir());
|
||
fn.AppendDir("..");
|
||
fn.MakeAbsolute();
|
||
fn.SetFullName("install.ini");
|
||
const wxString strLocalPath = fn.GetPath();
|
||
|
||
//quale e' il path web da cui aggiornarmi?
|
||
wxString strRemotePath;
|
||
{
|
||
//Install.ini locale da cui leggere il path di dove sta il mio server web
|
||
CampoIniFile iniLocalInstall(fn.GetFullPath(), "Main");
|
||
strRemotePath = iniLocalInstall.Get("WebPath");
|
||
}
|
||
|
||
//aggiornamento dei moduli SY e SR via web
|
||
//il modulo SY va aggiornato comunque
|
||
InternetUpdateModule(strLocalPath, strRemotePath, "sy");
|
||
//il modulo SR va aggiornato solo se usato (si sta aggiornando il cpu con il gestore delle chiavi)
|
||
if (m_bLurchWasRunning)
|
||
InternetUpdateModule(strLocalPath, strRemotePath, "sr");
|
||
|
||
//lanciare ba1.exe -6 in uscita
|
||
wxSetWorkingDirectory(strLocalPath);
|
||
wxExecute("ba1 -6 /uADMIN");
|
||
}
|
||
|
||
//--------------------------------------------------------------------------
|
||
//metodo per tutte le installazioni e gli aggiornamenti automatici in locale
|
||
//--------------------------------------------------------------------------
|
||
void CampoSetup::NormalSetup()
|
||
{
|
||
//creazione del CampoWizard, ovvero dell'insieme di finestre per gestire installazione/aggiornamento
|
||
m_pWizard = new CampoWizard(m_pMainFrame);
|
||
|
||
if (m_pWizard->Run())
|
||
{
|
||
//e' una DEMO o una versione normale?
|
||
const bool bInstallDemoVersion = m_pWizard->GetInstDemoVersion();
|
||
|
||
|
||
// 1) RACCOLTA PARAMETRI GENERALI INSTALLAZIONE (tipo,path,cartelle,servers,...)
|
||
//------------------------------------------------------------------------------
|
||
//tipo di installazione/aggiornamento
|
||
const InstallationType uInstallationType = m_pWizard->GetInstallationType();
|
||
const bool bNewInstallation = uInstallationType != it_upgrade;
|
||
//installazione servers? solo per server di campo
|
||
const bool bInstallLurch = uInstallationType == it_server && (m_pWizard->GetInstUseAuth() || m_pWizard->GetInstUseDict()) && (!bInstallDemoVersion);
|
||
//uso servers? sarebbe solo per i client ma lo teniamo buono per tutti
|
||
const bool bUseLurch = uInstallationType != it_server && (!m_pWizard->GetSrvAuth().IsEmpty() || !m_pWizard->GetSrvDict().IsEmpty()) && (!bInstallDemoVersion);
|
||
//installazione datidemo? (oddio speriamo di no!; comunque vale solo per installazione standard)
|
||
const bool bInstallDemoData = uInstallationType == (it_standalone && m_pWizard->GetInstDemoData()) || (bInstallDemoVersion);
|
||
//cartelle selezionate dall'utente
|
||
const wxString& strPrgLocPath = m_pWizard->GetPrgLocPath();
|
||
const wxString& strDataPath = m_pWizard->GetDataPath();
|
||
|
||
//se nuova installazione deve anche creare la directory di destinazione
|
||
if (bNewInstallation)
|
||
{
|
||
//creazione della directory dei programmi (compreso l'intero albero directory)
|
||
CheckAndMakeDir(strPrgLocPath, "programmi");
|
||
//creazione della directory dei dati (compreso l'intero albero directory)
|
||
//un client NON installa i dati!! (senno' e' una installazione locale semplice)
|
||
if (uInstallationType != it_client)
|
||
CheckAndMakeDir(strDataPath, "dati");
|
||
}
|
||
|
||
|
||
// 2) COPIA DEI FILES DI INSTALLAZIONE DALLA CARTELLA CAMPO (E SUBDIRS) (SU CD) ALLA CARTELLA DESTINAZIONE
|
||
//--------------------------------------------------------------------------------------------------------
|
||
//copia del contenuto della cartella campo nella cartella di destinazione (installaz/aggiornam)
|
||
//per prima cosa cerca la cartella dei files sorgente...
|
||
wxArrayString asFilesList;
|
||
wxFileName strSourcePath(GetSetupDir(), "*.*");
|
||
strSourcePath.AppendDir("..");
|
||
strSourcePath.AppendDir("..");
|
||
strSourcePath.AppendDir("campo"); // NOME fisso della cartella del CD, non mettere APPNAME
|
||
strSourcePath.MakeAbsolute();
|
||
//stringa inutile al programma ma decisiva per il programmatore
|
||
const wxString strSrc = strSourcePath.GetPath();
|
||
//..contando anche quanti sono e memorizzandoli in un array asFileList
|
||
const size_t uFilesToCopy = wxDir::GetAllFiles(strSrc, &asFilesList);
|
||
|
||
const size_t nPathLenght = strSrc.Len();
|
||
//progress bar
|
||
CampoProgressDialog pi("Installazione Dati e Programmi di base...", (int)uFilesToCopy, m_pWizard);
|
||
|
||
for (size_t i = 0; i < uFilesToCopy; i++)
|
||
{
|
||
//per ogni file da copiare controlla i path sorgente e destinazione(problema con sottodirectory tipo..
|
||
//..dati); strFileCurr va lasciato qui perche' DEVE ESSERE AZZERATO ad ogni cambio file!!!!!!
|
||
wxString strFileCurr;
|
||
|
||
//controlla se il file corrente e' dentro una sottodirectory (tipo dati,servers,ecc...) oppure e' al..
|
||
//..primo livello (quindi e' un file di programma)
|
||
wxString strSourceFile = asFilesList[i].Lower();
|
||
NormalizeSlash(strSourceFile);
|
||
|
||
//e' in una subdir se la lunghezza del suo path prima dell'ultimo '/' e' > della lunghezza del path di root
|
||
const bool bIsSubDir = strSourceFile.Find('/', true) > (int)nPathLenght;
|
||
|
||
//2A) files con subdirectory
|
||
if (bIsSubDir)
|
||
{
|
||
//files dei dati standard! solo in caso di nuova installazione!! E NON installazione DEMO!!
|
||
if (strSourceFile.Find("/dati/") > 0)
|
||
{
|
||
//i DATI NON VANNO MAI installati in caso di aggiornamento!!!
|
||
//i DATI NON VANNO MAI installati in caso di installazione client!!!
|
||
//e nemmeno in caso si scelga di installare i dati demo (senno' sporca la dir dati e i datidemo non si installano)
|
||
//Ricordare che c'e' gi<67> stato il controllo nella Forward della pagina di selezione, quindi la cartella..
|
||
//..di destinazione e' comunque vuota
|
||
if (bNewInstallation && uInstallationType != it_client && !bInstallDemoData)
|
||
{
|
||
strFileCurr = strDataPath;
|
||
strFileCurr += asFilesList[i].Mid(nPathLenght + 5);
|
||
//Ulteriore controllo di sicurezza: se trova il file di destinazione gi<67> presente..
|
||
//..NON lo sovrascrive (lo mette vuoto cosi' non lo copia)
|
||
if (wxFileName::FileExists(strFileCurr))
|
||
strFileCurr = "";
|
||
}
|
||
else
|
||
strFileCurr = "";
|
||
|
||
} else
|
||
if (strSourceFile.Find("/datidemo/") > 0)
|
||
{
|
||
//i DATIDEMO vanno copiati solo in caso di installazione DEMO o di installazione standalone con specifica..
|
||
//richiesta di installazione DATIDEMO
|
||
if (bInstallDemoData)
|
||
{
|
||
strFileCurr = strDataPath;
|
||
strFileCurr += asFilesList[i].Mid(nPathLenght + 9);
|
||
if (wxFileName::FileExists(strFileCurr))
|
||
strFileCurr = "";
|
||
}
|
||
else
|
||
strFileCurr = "";
|
||
|
||
} else
|
||
if (strSourceFile.Find("/servers/") > 0) //che fare con i servers? copiare la directory...
|
||
{
|
||
if (bInstallLurch && !bInstallDemoVersion) //..ma solo se devi installare i servers
|
||
{
|
||
strFileCurr = strPrgLocPath;
|
||
strFileCurr += "/servers";
|
||
strFileCurr += asFilesList[i].Mid(nPathLenght + 8);
|
||
}
|
||
else
|
||
strFileCurr = "";
|
||
}
|
||
else //files vari di altre subdirectory che si installano sempre (es. recdesc)
|
||
{
|
||
strFileCurr = strPrgLocPath;
|
||
strFileCurr += asFilesList[i].Mid(nPathLenght);
|
||
}
|
||
}
|
||
//2B) files senza subdirectory (programmi!)
|
||
else
|
||
{
|
||
strFileCurr = strPrgLocPath;
|
||
strFileCurr += asFilesList[i].Mid(nPathLenght);
|
||
}
|
||
//copia i files nella cartella di destinazione (programmi,dati,cazzi e mazzi);se il nome del file..
|
||
//..di destinazione e' vuoto significa che non lo deve copiare!! (es. dati in aggiornamento)
|
||
if (!strFileCurr.IsEmpty())
|
||
{
|
||
//aggiorna la progind
|
||
if (!pi.Update((int)i, asFilesList[i]))
|
||
break;
|
||
//normalizza per sicurezza il nome (completo di path) del file (visto che ci sono metodi cui piace..
|
||
//..aggiungere / o \ a piacere..
|
||
NormalizeSlash(strFileCurr);
|
||
|
||
//eventuali sottodirectory le crea (solo se hanno un nome) e poi copia fisicamente i files
|
||
//se un file non si copia interrompe l'installazione con un ErrorBox
|
||
if (!CopyFilesAndDirs(asFilesList[i], strFileCurr, true))
|
||
break;
|
||
} //if (!strFileCurr.IsEmpty()..
|
||
} //for(size_t...
|
||
|
||
UpdateInstallIni(strSrc + "/install.ini", strPrgLocPath + "/install.ini", "sy");
|
||
if (bInstallLurch)
|
||
UpdateInstallIni(strSrc + "/install.ini", strPrgLocPath + "/install.ini", "sr");
|
||
|
||
|
||
// 3) COPIA DELLA CARTELLA SETUP DA CD (PROGRAM\SETUP) A CARTELLA DI DESTINAZIONE
|
||
//-------------------------------------------------------------------------------
|
||
//Funziona tutto come al punto 2)! Cambiano solo i path (sorgente = program\setup, destinazione = destdir\setup)
|
||
wxArrayString asSetupFilesList;
|
||
wxFileName fnSetupSourcePath(GetSetupDir(), "*.*");
|
||
fnSetupSourcePath.MakeAbsolute();
|
||
|
||
const wxString strSetupSrc = fnSetupSourcePath.GetPath();
|
||
const wxString strSetupDst = strPrgLocPath + "/setup";
|
||
|
||
const size_t uSetupFilesToCopy = wxDir::GetAllFiles(strSetupSrc, &asSetupFilesList);
|
||
const size_t nSetupPathLenght = strSetupSrc.Len();
|
||
CampoProgressDialog po(_("Copia cartella Setup..."), (int)uSetupFilesToCopy, m_pWizard);
|
||
|
||
wxString strFileCurr;
|
||
|
||
for (size_t i = 0; i < uSetupFilesToCopy; i++)
|
||
{
|
||
wxString strSourceFile = asSetupFilesList[i].Lower();
|
||
NormalizeSlash(strSourceFile);
|
||
strFileCurr = strSetupDst;
|
||
strFileCurr += asSetupFilesList[i].Mid(nSetupPathLenght);
|
||
|
||
if (!strFileCurr.IsEmpty())
|
||
{
|
||
if (!po.Update((int)i, asSetupFilesList[i]))
|
||
break;
|
||
NormalizeSlash(strFileCurr);
|
||
|
||
if (!CopyFilesAndDirs(asSetupFilesList[i], strFileCurr, true))
|
||
break;
|
||
}
|
||
}
|
||
|
||
// ?) INSTALLAZIONE DATI DEMO
|
||
//---------------------------
|
||
//installazione dei dati dimostrativi (che schifo!).Non si puo' fare in aggiornamento!
|
||
/* if (bInstallDemoData && uInstallationType < 3)
|
||
{
|
||
//trova la cartella datidemo da copiare
|
||
wxArrayString asDataList;
|
||
const wxString strSrc = GetSourceDir("datidemo");
|
||
//conta i files da copiare e si lancia nell'operazione di copiatura...
|
||
//Vale quanto detto per l'installazione dell'area dati
|
||
const size_t uFilesToCopy = wxDir::GetAllFiles(strSrc, &asDataList);
|
||
wxString strFileCurr;
|
||
const size_t nPathLenght = strSrc.Len();
|
||
CampoProgressDialog pi("Installazione Dati Demo...", (int)uFilesToCopy, m_pWizard);
|
||
for (size_t i = 0; i < uFilesToCopy; i++)
|
||
{
|
||
if (!pi.Update((int)i, asDataList[i]))
|
||
break;
|
||
|
||
asDataList[i].Lower();
|
||
strFileCurr = strDataPath;
|
||
strFileCurr += asDataList[i].Mid(nPathLenght);
|
||
|
||
if (!strFileCurr.IsEmpty())
|
||
{
|
||
//eventuali sottodirectory le crea (solo se hanno un nome) e poi copia fisicamente i files
|
||
//se un file non si copia interrompe l'installazione con un ErrorBox
|
||
if (!CopyFilesAndDirs(asDataList[i], strFileCurr, false))
|
||
break;
|
||
} //if (!strFileCurr.IsEmpty()..
|
||
} //for (size_t i = 0...
|
||
} //if(bInstallDemoData... */
|
||
|
||
|
||
// 4) COMPILAZIONE CAMPO.INI CON CONFIGURAZIONE NUOVA INSTALLAZIONE
|
||
//-----------------------------------------------------------------
|
||
//adesso deve compilare il campo.ini se nuova installazione..
|
||
if (bNewInstallation)
|
||
{
|
||
{ //parentesi necessaria per la scrittura immediata (non cancellare! serve per debug)
|
||
//paragrafo [Main]
|
||
CampoIniFile CampoIniMain(strPrgLocPath + "/campo.ini", "Main");
|
||
const unsigned int uDongleType = m_pWizard->GetDongleType(); // 3 o 4 dopo la morte delle chiavi hw
|
||
CampoIniMain.Set("Donglehw", uDongleType);
|
||
CampoIniMain.Set("Study", strDataPath);
|
||
CampoIniMain.Set("Firm", "com");
|
||
//server,client o standalone?
|
||
CampoIniMain.Set("Type", uInstallationType);
|
||
}
|
||
//paragrafo [Server]
|
||
if (bInstallLurch || bUseLurch)
|
||
{
|
||
CampoIniFile CampoIniSrv(strPrgLocPath + "/campo.ini", "Server");
|
||
CampoIniSrv.Set("Dongle", m_pWizard->GetSrvAuth());
|
||
// CampoIniSrv.Set("Dictionary", m_pWizard->GetSrvDict());
|
||
}
|
||
} //if(bNewInstallation...
|
||
else //e' un aggiornamento! scrive il type
|
||
{
|
||
CampoIniFile CampoIniMain(strPrgLocPath + "/campo.ini", "Main");
|
||
//SOLO se sta aggiornando una versione antecedente alla 10.0 scrive la variabile Type nel campo.ini..
|
||
//..ovvero deve testare se Type = 0
|
||
if (CampoIniMain.GetInt("Type") == 0)
|
||
CampoIniMain.Set("Type", CampoIniMain.GetInstallationType());
|
||
}
|
||
|
||
|
||
// 5) COMPILAZIONE\AGGIORNAMENTO INSTALL.INI CON DISKPATH
|
||
//-------------------------------------------------------
|
||
//..e modificare comunque l'install.ini aggiornando eventualmente l'origine dei programmi
|
||
//parentesi necessaria per la scrittura immediata (non cancellare! serve per debug)
|
||
{
|
||
CampoIniFile CampoInstall(strPrgLocPath + "/install.ini", "Main");
|
||
if (uInstallationType == it_client) //client: directory origine sul server
|
||
CampoInstall.Set("DiskPath", m_pWizard->GetPrgNetPath());
|
||
else //e' il path assoluto dell'install.ini che sta in 'program' (es. D:\program)
|
||
{
|
||
const wxString strSrc = GetSourceDir("program");
|
||
CampoInstall.Set("DiskPath", strSrc);
|
||
}
|
||
}
|
||
|
||
|
||
// 6) AGGIORNAMENTO DI ADMIN.INI CON IL TEMA DEL RESELLER
|
||
//---------------------------------------------------------
|
||
//carica il tema predefinito del reseller dentro l'admin.ini che sta in cartella programmi\dati\config..
|
||
//..in modo da vederli subito quando lancer<65> ba1 (e successivamente ba0)
|
||
if (bNewInstallation)
|
||
{
|
||
//file sorgente
|
||
const wxString strThemeFileName = Theme();
|
||
wxString strSrcThemePath = GetSetupDir();
|
||
strSrcThemePath << strThemeFileName;
|
||
CampoIniFile CampoTheme(strSrcThemePath, "Standard");
|
||
|
||
//file di destinazione
|
||
CampoIniFile CampoDestAdmin(strDataPath + "/config/admin.ini", "Colors");
|
||
|
||
//copia del tema standard nell'admin.ini di destinazione
|
||
long nIndex;
|
||
wxString strKey;
|
||
//ciclo su tutte le variabili del paragrafo di origine
|
||
for (bool ok = CampoTheme.GetFirstEntry(strKey, nIndex); ok; ok = CampoTheme.GetNextEntry(strKey, nIndex))
|
||
{
|
||
//copia nel corrispondente paragrafo di destinazione
|
||
CampoDestAdmin.Set(strKey, CampoTheme.Get(strKey));
|
||
}
|
||
}
|
||
|
||
|
||
// 7) AGGIORNAMENTO DEL MODULO SY CON EVENTUALI PATCH PRESENTI IN PROGRAM DEL CD E AGGIORNAMENTO INSTALL.INI
|
||
//----------------------------------------------------------------------------------------------------------
|
||
//procede poi al caricamento delle patch eventuali di sistema all'interno della dir 'program' e al..
|
||
//..conseguente riaggiornamento del livello versione/patch di SY ed SR in install.ini
|
||
const wxString strPrgCDPath = GetSourceDir("program");
|
||
if (wxFileName::DirExists(strPrgCDPath))
|
||
{
|
||
const wxString strSetupCDPath = strPrgCDPath + "/setup";
|
||
const wxString strSetupLocPath = strPrgLocPath + "/setup";
|
||
//Procedura di salvataggio del corrente OEM (reseller) del prg gi<67> installato; in questo modo anche..
|
||
//..mandando un CD AGA (che generalmente funziona!) ad un cliente di un distributore non AGA, il reseller..
|
||
//..a video non cambia. Per cambiare reseller si dovr<76> intervenire a mano sull'oem.ini cambiando il valore..
|
||
//..di OEM dopo l'installazione
|
||
const wxString strOemLocPath = strSetupLocPath + "/oem.ini";
|
||
CampoIniFile CampoIniOem(strOemLocPath, "MAIN");
|
||
const int nOldOem = CampoIniOem.GetInt("OEM");
|
||
//svuota proprio la directory setup in modo da non coservare files indesiderati
|
||
EmptyOutDir(strOemLocPath);
|
||
//copia la directory setup da CD a locale
|
||
CopyDir(strSetupCDPath, strSetupLocPath);
|
||
//rimette a posto la candela...cio<69>, il reseller
|
||
CampoIniOem.Set("OEM", nOldOem);
|
||
//..Fine dell'aggiornamento della cartella setup
|
||
|
||
//scompattamento dei moduli e delle patch che eventualmente trova su CD per quanto riguarda i moduli SY..
|
||
UnzipModule(strPrgLocPath, strPrgCDPath, wxString("sy"));
|
||
//..ed SR ma solo se richiesto in fase di installazione
|
||
if (bInstallLurch)
|
||
UnzipModule(strPrgLocPath, strPrgCDPath, wxString("sr"));
|
||
}
|
||
|
||
|
||
// 8) CREAZIONE AUTOSTART DEI SERVERS (SE CI SONO)
|
||
// ------------------------------------------------
|
||
// Se sta installando Campo in postazione server e deve installare un gestore di servizi,
|
||
// avvia la procedura della creazione dell'autostart(un casino).
|
||
// Questa procedura non puo' valere per l'aggiornamento, che agisce in modo diverso
|
||
if (bNewInstallation)
|
||
{
|
||
const LurchMode iSrvAutostartMode = m_pWizard->GetSrvAutostartMode();
|
||
if (iSrvAutostartMode != lm_none)
|
||
CreateAutostartLurch(iSrvAutostartMode, strPrgLocPath);
|
||
}
|
||
|
||
|
||
// 9) CREAZIONE DELL'ICONA SUL DESKTOP
|
||
//------------------------------------
|
||
const bool bDesktopShortcut = m_pWizard->GetDesktopShortcut();
|
||
if (bDesktopShortcut)
|
||
{
|
||
const wxFileName strExe(strPrgLocPath, wxT("ba0.exe"));
|
||
|
||
CampoIniFile CampoIniMain(strPrgLocPath + "/campo.ini", "Main");
|
||
InstallationType nInstType = CampoIniMain.GetInstallationType();
|
||
|
||
wxString strLnk = Product();
|
||
switch (nInstType)
|
||
{
|
||
case it_server: strLnk += " (Server)"; break;
|
||
case it_client: strLnk += " (Client)"; break;
|
||
default: break;
|
||
}
|
||
|
||
//crea comunque l'icona
|
||
CreateIcon(CSIDL_COMMON_DESKTOPDIRECTORY, strExe, strLnk);
|
||
}
|
||
|
||
|
||
// 10) AGGIORNAMENTO CAMPO.STP
|
||
//---------------------------
|
||
if (bNewInstallation)
|
||
{
|
||
//deve aggiungere la nuova installazione al campo.stp
|
||
for (int i = 1; ; i++)
|
||
{
|
||
wxString strGroup;
|
||
strGroup << i;
|
||
CampoIniFile CampoStp("C:\\campo.stp", strGroup);
|
||
const wxString strPath = CampoStp.Get("Program");
|
||
if (strPath.IsEmpty() || strPath.CmpNoCase(strPrgLocPath) == 0)
|
||
{
|
||
CampoStp.Set("Program", strPrgLocPath);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
// 11) CHIUDE IL SETUP LANCIANDO BA1 -6 PER INSTALLAZIONE MODULI
|
||
//-------------------------------------------------------------
|
||
//lanciare ba1.exe -6 in uscita
|
||
if (wxSetWorkingDirectory(strPrgLocPath))
|
||
wxExecute("ba1 -6 /uADMIN");
|
||
else
|
||
ErrorBox("Impossibile installare i moduli: cartella di destinazione irraggiungibile!");
|
||
|
||
|
||
} //if (m_pWizard->Run())...
|
||
m_pWizard->Destroy();
|
||
}
|
||
|
||
//------------------------------------------------------------------------------------------------------
|
||
////////////////////////////////////////////////////////////////////////////////////
|
||
// Metodi per il controllo preventivo di eventuali cazzate in procinto di accadere
|
||
////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
bool CampoSetup::SystemRunning(const wxString& strAppName, wxString strMsg) const
|
||
{
|
||
strMsg.Replace(wxT("PRODUCT"), PRODUCT);
|
||
strMsg += "\nSi desidera ritentare?";
|
||
|
||
bool bRunning = false;
|
||
bool bRetry = true;
|
||
while (bRetry)
|
||
{
|
||
int i;
|
||
for (i = 10; i > 0 && FindProcessId(strAppName); i--)
|
||
wxSleep(1);
|
||
|
||
bRetry = false;
|
||
bRunning = i <= 0;
|
||
if (bRunning && !strMsg.IsEmpty())
|
||
{
|
||
bRetry = YesNoBox(strMsg);
|
||
}
|
||
}
|
||
|
||
return bRunning;
|
||
}
|
||
|
||
|
||
int CampoSetup::LurchRunning() const
|
||
{
|
||
//cerca SSAservice che funziona come servizio
|
||
int run = 0;
|
||
if (SystemRunning("SSAservice", wxEmptyString))
|
||
run |= 1;
|
||
if (!run)
|
||
{
|
||
//...se non lo trova cerca il solo Authoriz come programma...
|
||
if (SystemRunning("Authorization", wxEmptyString))
|
||
run |= 2;
|
||
}
|
||
return run;
|
||
}
|
||
|
||
|
||
bool CampoSetup::CampoIsRunning() const
|
||
{
|
||
//ricerca di campo.aut per avere la lista dei moduli
|
||
//prima tenta con aggiornamento da disco...
|
||
wxString strInstallPath = "../install.ini";
|
||
//...poi con aggiornamento da CD
|
||
if (!wxFileName::FileExists(strInstallPath))
|
||
strInstallPath = "../../campo/install.ini";
|
||
|
||
//fa un giro sull'install.ini alla ricerca di tutti i moduli (sono i paragrafi lunghi 2) installati (se aggiornamento..
|
||
//..da disco) o da installare (se sta installando da CD)
|
||
wxArrayString asModuli;
|
||
if (wxFileName::FileExists(strInstallPath))
|
||
{
|
||
wxString strModulo;
|
||
long nIndex;
|
||
CampoIniFile iniInstall(strInstallPath, strModulo);
|
||
for (bool ok = iniInstall.GetFirstGroup(strModulo, nIndex); ok; ok = iniInstall.GetNextGroup(strModulo, nIndex))
|
||
{
|
||
if (strModulo.Len() == 2)
|
||
asModuli.Add(strModulo); //aggiunge all'array tutti i moduli che trova in install.ini
|
||
}
|
||
}
|
||
else //non trova nessun install.ini (non dovrebbe mai accadere) e tenta i moduli pi<70> importanti
|
||
{
|
||
asModuli.Add("ba");
|
||
asModuli.Add("cg");
|
||
asModuli.Add("ve");
|
||
}
|
||
|
||
//scandisce l'array dei moduli alla ricerca di un eventuale programma di campo ancora running a sua insaputa
|
||
wxString strAppName;
|
||
for (size_t i = 0; i < asModuli.GetCount(); i++)
|
||
{
|
||
for (size_t j = 0; j <= 9; j++)
|
||
{
|
||
strAppName = asModuli[i];
|
||
strAppName += ('0'+j);
|
||
wxSingleInstanceChecker sicProgram(strAppName);
|
||
if (sicProgram.IsAnotherRunning())
|
||
{
|
||
strAppName << " <20> in esecuzione! E' necessario terminarlo utilizzando la Gestione Attivit<69> di Windows.";
|
||
ErrorBox(strAppName);
|
||
return true;
|
||
}
|
||
|
||
}
|
||
}
|
||
return false; //campo non sta andando
|
||
}
|
||
|
||
//metodo principale che sceglie la modalit<69> di lancio del programma
|
||
void CampoSetup::OnTimer(wxTimerEvent& WXUNUSED(e))
|
||
{
|
||
//controllo di un eventuale setup gi<67> lanciato (tipico di utonti e della premiata ditta bib<69> & bib<69>)
|
||
wxSingleInstanceChecker sicSetup("SetCmpUp");
|
||
if (sicSetup.IsAnotherRunning())
|
||
{
|
||
wxString msg;
|
||
msg << "Un'installazione di " << PRODUCT << " <20> gi<67> in esecuzione!";
|
||
ErrorBox(msg);
|
||
m_pMainFrame->Destroy();
|
||
return;
|
||
}
|
||
|
||
//controllo di eventuali Campo o servers attivi e conseguente interruzione dell'installazione
|
||
m_bLurchWasRunning = LurchRunning() != 0;
|
||
if (m_bLurchWasRunning)
|
||
{
|
||
wxString msg;
|
||
msg << "Per poter aggiornare/installare il programma " << PRODUCT
|
||
<< " deve temporaneamente essere disattivato il gestore delle licenze!\n"
|
||
<< "Prima di disattivare il gestore delle licenze accertarsi che tutti gli utenti spengano il programma!!\n"
|
||
<< "Proseguire con la disattivazione?";
|
||
if (YesNoBox(msg))
|
||
StopLurch();
|
||
else
|
||
{
|
||
m_pMainFrame->Destroy();
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (SystemRunning("ba0", "Uscire dal programma PRODUCT prima di procedere con l'aggiornamento/installazione!") ||
|
||
SystemRunning("ba1", "Uscire dal programma di manutenzione di PRODUCT\n prima di procedere con l'aggiornamento/installazione!"))
|
||
{
|
||
m_pMainFrame->Destroy();
|
||
return;
|
||
}
|
||
|
||
if (CampoIsRunning())
|
||
{
|
||
wxString msg;
|
||
msg << "Un applicativo di " << PRODUCT << " <20> ancora in esecuzione!\n"
|
||
<< "L'installazione sar<61> interrotta immediatamente";
|
||
ErrorBox(msg);
|
||
m_pMainFrame->Destroy();
|
||
return;
|
||
}
|
||
|
||
//path del programma setup.exe in esecuzione; serve in seguito in quanto alcuni metodi (tipo la GetAllFiles)..
|
||
//..fanno perdere questo path
|
||
//attenzione!!! il path DEVE terminare con "\" senn<6E> in base al tipo di chiamata (-uw,-uc,-ud) i rispettivi..
|
||
//..metodi funzionano a casaccio!!!
|
||
const wxString strCommand = argv[1];
|
||
|
||
if (strCommand.IsEmpty())
|
||
{
|
||
TCHAR strFileName[260];
|
||
::GetModuleFileName(NULL, strFileName, 260);
|
||
|
||
wxFileName strPath(strFileName);
|
||
strPath.MakeAbsolute();
|
||
m_strSetupPath = strPath.GetPath();
|
||
if (!m_strSetupPath.EndsWith(wxT("\\")))
|
||
m_strSetupPath << '\\';
|
||
|
||
wxSetWorkingDirectory(m_strSetupPath);
|
||
|
||
//installazione normale da CD
|
||
NormalSetup();
|
||
}
|
||
else
|
||
{
|
||
//attenzione: modifica richiesta perch<63> la cartella di esecuzione di setup <20> diversa nel caso sia un..
|
||
//..aggiornamento o una installazione da CD
|
||
m_strSetupPath = wxGetCwd();
|
||
m_strSetupPath.MakeLower();
|
||
if (!m_strSetupPath.EndsWith("setup"))
|
||
{
|
||
if (!m_strSetupPath.EndsWith(wxT("\\")))
|
||
m_strSetupPath << '\\';
|
||
m_strSetupPath << "setup";
|
||
wxSetWorkingDirectory(m_strSetupPath);
|
||
}
|
||
if (!m_strSetupPath.EndsWith(wxT("\\")))
|
||
m_strSetupPath << '\\';
|
||
|
||
//aggiornamento da disco,client,web
|
||
if (strCommand == "-ud")
|
||
DiskUpdate(); else
|
||
if (strCommand == "-uc")
|
||
ClientUpdate(); else
|
||
if (strCommand == "-uw")
|
||
InternetUpdate();
|
||
}
|
||
// finestrina x chiudere a mano il programma (sconsigliata causa lancio ba1.exe)
|
||
// ::wxMessageBox(wxT("Installazione terminata"), APPNAME, wxOK | wxICON_INFORMATION);
|
||
m_pMainFrame->Destroy();
|
||
}
|
||
|
||
|
||
bool CampoSetup::OnInit()
|
||
{
|
||
wxInitAllImageHandlers();
|
||
m_locale.Init();
|
||
|
||
m_pWizard = NULL; //finestra di programma nulla;deve esistere solo per il NormalSetup dove viene inizializzata
|
||
m_pMainFrame = new CampoFrame;
|
||
SetTopWindow(m_pMainFrame);
|
||
|
||
wxTimerEvent e(883);
|
||
AddPendingEvent(e);
|
||
|
||
return true;
|
||
}
|