// Xcelera 2.2 SP1 update installer framework
// Philips Healthcare, BU-CAI Best, NL.
// helpdesk.MIT@philips.com
//
// Note: a log file will be is generated for each run in %TEMP% folder
//
// usage: installSP1.js <-u> <-auto>
// -u is UNINSTALL mode. Default (no flag) is INSTALL
//
// tbd. ViewForum update 
//
// version 0.1 - initial.
// version 0.2 - after first tests
// version 0.3 - after Otmar's feedback
// version 0.4 - after T-Con Andover 4th June 08
// version 0.5 - adding Questra, Accounts.xml update
// version 0.7 - update after test
// version 0.8 - include 'ProgressBar' functionality
// version 0.9 - include 'AutoUpdate' functionality
// version 1.0 - implement MIT00031409 - 'Reboot required after SP1 installation' 
// version 1.1 - implement MIT00031366 - 'Sequence install script SP1 and main installer not correct during uninstall'
// version 1.2 - implement MIT00031437 - 'HA: SP1 installation fails on cluster, US called with wrong parameter'
// version 1.3 - implement MIT00031383 - SP1 installer logfile should be in unicode iso ansi for localized OS install
// version 1.4 - implement MIT00031405 - Rename the installer exe to Xcelera22L1SP1.exe
// version 1.5 - implement MIT00022413 - Xcelera Main SP1 in Add/Remove Programs not consistent with other entries
// version 1.6 - implement MIT00022426 - Warnings in 221 SP1 installation log
// version 1.7 - implement MIT00031372 - Install Script doesn't catch error if Platform fails
// version 1.8 - implement MIT00031365 - Wrong message is displayed during uninstall
// version 1.9 - implement MIT00022432 - Running 2.2L1 SP1 installer as non-administrator not working correctly
// version 2.0 - implement MIT00031366 - 'Sequence install script SP1 and main installer not correct during uninstall' - add more code
// version 2.1 - implement MIT00031536 - Remove restart timer at end of SP1 installer
// version 2.2 - implement MIT00031636 - Xcelera SP1 installer fails to copy auto update installer to server
// version 2.3 - implement MIT00031366 - Sequence install script SP1 and main installer not correct during uninstall
// version 2.4 - implement MIT00031598 - HA: Autoupdate does not start for workstation connected to HA clustered server
// version 2.5 - implement MIT00000000 - HA: Incorporate HA server patch
// NOTE - ensure 'szVersion' below is updated before each delivery...
// start global
try {
		szVersion = "2.5";
	 	var WSHShell = WScript.CreateObject("WScript.Shell");
		var fso = new ActiveXObject("Scripting.FileSystemObject");  
		var sTitle = "Xcelera 2.2L1SP1 Installer v" + szVersion;
		var utilList = new Array(	"Localizer.dll",
									"ProgressBar.dll"	
								  );
	 	var gLogName, gLogStream;
	 	var cmd_line;				// Re-usable command string
	 	var bUninstallMode = false;		// default is 'install'
	 	var bAutoClientMode = false;	// if launched by 'XceleraClientUpdate.exe'
	 	var bClusterMode = false;
		var progLine1, progLine2;

		CreateLogFile();

		var gpPath = GetGrandParentPath();
		var re = new RegExp("XceleraClientUpdate.exe", "i"); // ignore case
		if(gpPath && gpPath.search(re) != -1)
			bAutoClientMode = true;

		// Get back any cmd line args
		if(WScript.Arguments.Length > 1)
			throw "Too many command line arguments !\r\nThere is 1 possible argument: <-u> (for uninstall) !";	
		else
		if(WScript.Arguments.Length == 1)
		{
			cmd_line = WScript.Arguments(0);
			cmd_line = cmd_line.toLowerCase();
			if( (cmd_line == "-u") || (cmd_line == "/u") )
				bUninstallMode = true;
		}
		
		CheckUserIsAdmin();

		var szQuestion = "This application will ";
		if(bUninstallMode === true)
			szQuestion += "remove Xcelera 2.2L1\nService Pack 1 from";
		else
			szQuestion += "install Xcelera 2.2L1\nService Pack 1 on";
		szQuestion += " your system.\n\nDo you want to continue ?";
		
	 	if(bAutoClientMode == false)
	 	{
			var ret_val = WSHShell.Popup(szQuestion, 0, sTitle, 4 + 32); // Yes,No Question mark			
			if(ret_val != 6)
				ExitScript("User Cancelled");
		}

		var gRootFolderName = GetWorkingFolder();
		RegisterUtilities(gRootFolderName);
	
		try {
				var myPrgDlg = new ActiveXObject("Progress.ScriptUI");
			}
		catch(e)
			{ throw "Can't create ProgressBar instance !"; }
			
		bClusterMode = DetermineClusterMode(); // HA active ?
	
		if(bAutoClientMode == true)
			gLogStream.Write("\r\n* AutoClient mode = TRUE");		
		else
			gLogStream.Write("\r\n* AutoClient mode = FALSE");		
			
		if(bUninstallMode == true)
			gLogStream.Write("\r\n* Install mode = UN-INSTALL");		
		else
			gLogStream.Write("\r\n* Install mode = INSTALL");		
					
		// We're only updating 2.2 L1
		CheckInstalledVersion();
		
		var actionArray = new Array;
	
		if(bUninstallMode == true)
		{
			FillUninstallActions(actionArray); // Fixed list
			SetCWISresponseFile();
		}
		else
			ScanActions(actionArray);	// Find back what's to be done, from XML tags
		
		if(!actionArray.length)			// Nothing to do ?? Suspicious...
			throw "No actions found to execute !\r\nThe subfolders must contain update installation packages !";	
		
		// Sort into correct order
		actionArray.sort(sortFunc);
		
		if(bUninstallMode == true)
			DoubleCheckUninstall();		// Some items need 'cleanup' help

		// Carry out actions in sequence
		ExecuteActions(actionArray);
		
		if(bUninstallMode == false)
		{
			CopyScriptForUninstall();	// Copy this script onto system, so it can be un-installed later
			CopyExeForAutoUpdate();		// Make a copy of XceleraClientUpdate.exe in Xcelera\Programs
			ReWriteUninstallInfo();		// Leave our mark in the registry
			UpdateUltraSoundDB();			// Could be done in US installer too.
			QuestraUpdate(gRootFolderName + "\\questra");
			SetAccountsXMLPermission();
			RunHAPatch();				// Active on HA cluster only
		}
	}
catch(e)
	{
		ExitScript(e);
	}

	ExitScript("");

// end global

function RunHAPatch()
{
 try{
 		if(bClusterMode != true)
 			return;
 			
  		gLogStream.Write("\r\n* Applying HA Patch on cluster...");
 		WSHShell.Run("%COMSPEC% /C " + gRootFolderName + "\\Utility\\AutoUpdateHA.bat", 1, true);
 		gLogStream.Write(" Done.");
 	}
 catch(e)
 	{
 		ExitScript("Error in RunHAPatch(): " + e.description);
 	}	
   
} // End RunHAPatch()

function DoubleCheckUninstall()
{
 try{
  		gLogStream.Write("\r\n* Checking un-install items for completion...");
		var szProgPath = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\ProgramFilesDir");
  		
  		// 1 - Xcelera UltraSound
  		try {
				var regEntry = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{51A14F67-F7BA-4D34-8095-946426E3645C}\\InstallLocation");
				gLogStream.Write("\r\n*\tRemoving Xcelera Ultrasound... ");
				cmd_line = "\"" + szProgPath + "\\InstallShield Installation Information\\{51A14F67-F7BA-4D34-8095-946426E3645C}\\setup.exe\" /slave /remove";
				WSHShell.Run(cmd_line, 0, true);
				gLogStream.Write("Done.");
			}
		catch(e)
			{} // Doesn't exist, nothing to do


  		// 2 - Xcelera ViewForum
  		try {
				var regEntry = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{BB22AA59-6255-48FA-95C6-E6F9BCC9C101}\\InstallLocation");
				gLogStream.Write("\r\n*\tRemoving Xcelera ViewForum... ");
				cmd_line = "\"" + szProgPath + "\\InstallShield Installation Information\\{BB22AA59-6255-48FA-95C6-E6F9BCC9C101}\\setup.exe\" /slave /remove";
				WSHShell.Run(cmd_line, 0, true);
				gLogStream.Write("Done.");
			}
		catch(e)
			{} // Doesn't exist, nothing to do

  		// 3 - EPMED
  		try {
  				var mipFolder = szProgPath + "\\Philips\\Programs\\MIP-52.203.3015.1457\\" //MIP-52.203.3070.1233"  
  				var epDll = "\"" + mipFolder + "Philips.PmsIsa.Private.Base.Com2Dotnet.ComWrapper.EPWViewer.dll\"";
  				if(fso.FileExists(epDll) == true)
  				{
  					gLogStream.Write("\r\n*\tUnregistering EPWViewer... ");
  					cmd_line = fso.GetSpecialFolder(0) + "\\Microsoft.NET\\Framework\\v1.1.4322\\RegAsm.exe";
  					if(fso.FileExists(cmd_line) == true)
  					{
  						WSHShell.Run("%COMSPEC% /C " + cmd_line + " /unregister " + epDll, 0, true);
						gLogStream.Write("Done.");
					}
  				}
				var regEntry = WSHShell.RegRead("HKLM\\SOFTWARE\\EPMEDSYSTEMS\\EP-WORKMATE 2000\\CONFIG");
  				gLogStream.Write("\r\n*\tRemoving EPMED registry settings...");
				WSHShell.RegDelete("HKLM\\SOFTWARE\\EPMEDSYSTEMS");
				gLogStream.Write("Done.");
				if(fso.FolderExists("C:\\EPWM2000") == true)
				{
					gLogStream.Write("\r\n*\tRemoving EPMED folder... ");
					WSHShell.Run("%COMSPEC% /C attrib -r C:\\EPWM2000\\*.* /s", 0, true);
					fso.DeleteFolder("C:\\EPWM2000", true);
					gLogStream.Write("Done.");
				}
			}
		catch(e)
			{} // Doesn't exist, nothing to do

  		// 4 - Xcelera Platform
  		try {
				var regEntry = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{51D0666C-1CF7-4654-84A7-3576690BA2F1}\\InstallLocation");
				gLogStream.Write("\r\n*\tRemoving Xcelera Platform... ");
				cmd_line = "\"" + szProgPath + "\\InstallShield Installation Information\\{51D0666C-1CF7-4654-84A7-3576690BA2F1}\\setup.exe\" /slave /remove";
				WSHShell.Run(cmd_line, 0, true);
				gLogStream.Write("Done.");
			}
		catch(e)
			{} // Doesn't exist, nothing to do
	}
 catch(e)
 	{
 		ExitScript("Error in DoubleCheckUninstall(): " + e.description);
 	}	
   
} // End DoubleCheckUninstall()

function CheckUserIsAdmin()
{
 try{
 		gLogStream.Write("\r\n* Checking user priviliges...");
 		
		var WSHNetwork = WScript.CreateObject("WScript.Network");
		var sUserName = WSHNetwork.UserDomain;
		sUserName += "\\" + WSHNetwork.UserName;
		
 		WSHShell.RegWrite("HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\admintest\\", "");
 		WSHShell.RegDelete("HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\admintest\\");
		gLogStream.Write("\r\n* User: " + sUserName + " has admin rights !");
	}
 catch(e)
 	{
 		var sMesg = "Current user: " + sUserName + " has no ADMIN rights, exiting script.";
		gLogStream.Write("\r\n* " + sMesg);
		WSHShell.Popup(sMesg, 0, sTitle, 16);
 		ExitScript("Administrator permissions not found for user !");
 	}   		
} // End CheckUserIsAdmin()

function CheckLogFile(szLogName)
{
 try{
 		var bOK = false;			// assume the worst
 		var logPath = fso.GetSpecialFolder(2) + "\\" + szLogName;
 		gLogStream.Write("\r\n* Checking installer log file: " + logPath);
 		
 		var reSuccess = new RegExp("Success", "i");
 		var reAbort = new RegExp("Abort", "i");
		var logStream = fso.OpenTextFile(logPath);
		while(!logStream.AtEndOfStream)
		{
			var curLine = logStream.ReadLine();
			if(curLine.search(reSuccess) != -1)
				bOK = true;			// the last match will count
			if(curLine.search(reAbort) != -1)
				bOK = false;		// the last match will count
		}
		logStream.Close();			// Cleanup
		
		if(bOK == false)
			ExitScript("Installation error detected in logile: " + logPath);
		
		gLogStream.Write(" - OK");
 	}
 catch(e)
 	{
 		ExitScript("Error in CheckLogFile(): " + e.description);
 	}
} // End CheckLogFile()


function DetermineClusterMode()			// Running on HA ?
{
 try{
 		gLogStream.Write("\r\n* Looking for Cluster mode (HA) - ");
 		
 		var bIsCluster = false; 		// Assume not
 		try {
 				var ret_val = WSHShell.RegRead("HKLM\\SYSTEM\\CurrentControlSet\\Services\\ClusSvc\\DisplayName");
 				gLogStream.Write("found \"" + ret_val + "\"");
 				bIsCluster = true;		// Service exists only on cluster
 			}
 		catch(e)
 			{
 				gLogStream.Write("not found !");
 			}
 		return bIsCluster;
   	}
 catch(e)
 	{
 		ExitScript("Error in DetermineClusterMode(): " + e.description);
 	}
 	
} // End DetermineClusterMode();


function DetermineReboot()
{							// Check the RunOnce and RunOnceEx entries for any evidence of 'reboot'
 try{
 		var bReboot = false;
 		var re = new RegExp("reboot", "i");
 		var regData;
 		try {
 				regData = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce\\InstallShieldSetup");
		 		if(regData.search(re) != -1)
 					bReboot = true;
 			}
 		catch(e) {} // OK , doesn't exist

 		try {
 				regData = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx\\InstallShieldSetup");
		 		if(regData.search(re) != -1)
 					bReboot = true;
 			}
 		catch(e) {} // OK , doesn't exist
 
 		if(bReboot == false)
 			return;
 		
 		var ret_val = WSHShell.Popup("To complete the installation, the system must be restarted\n\nDo you want to restart now ?", 0, sTitle, 4 + 32)
 		if(ret_val == 6)
	 		WSHShell.Run("shutdown -r -t 00 -f -c \"" + sTitle + "\r\n\r\nThe update will be completed after the system has restarted.\"", 0, false);
   	}
 catch(e)
 	{
 		WScript.Quit(3); // Nothing else can be done...
 	}
 	
} // End DetermineReboot();

function CopyExeForAutoUpdate()
{
 try{
 		gLogStream.Write("\r\n* Copying XceleraClientUpdate.exe - ");
 		var szVersion = WSHShell.RegRead("HKLM\\SOFTWARE\\Philips\\Xcelera\\CurrentVersion");
 		var szSharePath = WSHShell.RegRead("HKLM\\SOFTWARE\\Philips\\Xcelera\\" + szVersion + "\\Common\\Programs Path");
 		
 		// Something special for HA
 		if(bClusterMode == true)
 		{
 			gLogStream.Write(" Cluster mode detected !");
 			var resultFileName = fso.GetTempName();
 			cmd_line = "%COMSPEC% /c cluster.exe resource Concorde /priv > \"" + resultFileName + "\"";
 			WSHShell.Run(cmd_line, 0, true);
 			
			var rePath = new RegExp("Path", "i");
			var clusterStream = fso.OpenTextFile(resultFileName);
			while(!clusterStream.AtEndOfStream)
			{
				var curLine = clusterStream.ReadLine();
				if(curLine.search(rePath) != -1)
				{	
					var reWhite = new RegExp("\\s");
					var myLineItems = curLine.split(reWhite);
					szSharePath = myLineItems[3] + "\\Programs";
					break;
				}
			}
			clusterStream.Close();	// Cleanup
			fso.DeleteFile(resultFileName, true);
 		}
 		szSharePath += "\\XceleraClientUpdate.exe";
 	
 		if(gpPath)
 		{
	 		gLogStream.Write("\r\n* gpPath: " + gpPath);
 			var myFile = fso.GetFile(gpPath);
 			gLogStream.Write("\r\n* szSharePath: " + szSharePath); 			
 			if(fso.FileExists(szSharePath) == true)
 			{
	 			var tgtFile = fso.GetFile(szSharePath);
	 			tgtFile.Attributes = 0; 		// Clear any 'read-only' flag
	 		}
	 		
 			myFile.Copy(szSharePath, true);
 			gLogStream.Write("\r\n* XceleraClientUpdate.exe copied !");
 			
 			// Fix permissions for HA - give Everyone read-only access
	 		if(bClusterMode == true)
 			{
 				gLogStream.Write("Fixing permissions for Cluster mode...");
	 			cmd_line = "%COMSPEC% /c cacls.exe " + szSharePath + " /E /G Everyone:R";
 				WSHShell.Run(cmd_line, 0, true);
 		 				
 				gLogStream.Write(" Done.");
 			}
 		}
 		else
 			gLogStream.Write("skipped - not launched from self-extracting module");
   	}
 catch(e)
 	{
 		ExitScript("Error in CopyExeForAutoUpdate(): " + e.description);
 	}
 	
} // End CopyExeForAutoUpdate();


function GetGrandParentPath()
{
 try{
	 	var wbemFlagReturnImmediately = 0x10;
		var wbemFlagForwardOnly = 0x20;
	
		var objWMIService = GetObject("winmgmts:\\\\.\\root\\CIMV2");
	  	var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_Process", "WQL");
	// First get our WScript.exe parent ID (for CMD.EXE)
		var re = new RegExp(WScript.ScriptName, "i"); // ignore case
		var parentID = 0, grandParentID = 0;
		var grandParentPath = "";
		var objItem;
		
		var enumItems = new Enumerator(colItems);
		for(; !enumItems.atEnd(); enumItems.moveNext())
	   	{
	    	objItem = enumItems.item();
	    	var objArgs = objItem.CommandLine;
	    	if(objItem.ProcessId && objArgs && objArgs.search(re) != -1)
	    	{
	    		parentID = objItem.ParentProcessId;
   		 		gLogStream.Write("\r\n* Found parent process PID: " + parentID);
	    		break;
	    	}
	  	}

	// Now get the grand-parent ID(parent of CMD.EXE)
	  	for(enumItems.moveFirst(); !enumItems.atEnd(); enumItems.moveNext())
	   	{
	    	objItem = enumItems.item();
	    	if(objItem.ProcessId && (objItem.ProcessId == parentID))
	    	{
	    		grandParentID = objItem.ParentProcessId;
   		 		gLogStream.Write("\r\n* Found grandparent PID: " + grandParentID);
	    		break;
	    	}
	    }
	// Now get the grand-parent path
	  	for(enumItems.moveFirst(); !enumItems.atEnd(); enumItems.moveNext())
	   	{
	    	objItem = enumItems.item();
	    	if(objItem.ProcessId && (objItem.ProcessId == grandParentID))
	    	{
	    		grandParentPath = objItem.ExecutablePath;
   		 		gLogStream.Write("\r\n* Found grandparent path: " + grandParentPath);
	    		break;
	    	}
	    }
   	}
 catch(e)
 	{
 		ExitScript("Error in GetGrandParentPath(): " + e.description);
 	}

    return grandParentPath;
 	
} // End GetGrandParentPath();

function RegisterUtilities(rootFolder)
{
try {
		gLogStream.Write("\r\n*\r\n* Registering utilities...");
		for(key in utilList)
		{
			cmd_line = "%COMSPEC% /C regsvr32 /s ";
			cmd_line += rootFolder + "\\Utility\\" + utilList[key];
			WSHShell.Run(cmd_line, 0, true);
		}
		gLogStream.Write(" Done.\r\n*");
	}
catch(e)
	{
		ExitScript("Error in RegisterUtilities(): " + e.description);
	}	
} // End RegisterUtilities()

function DisplayProgess(szLine1, szLine2)
{
try {
		myPrgDlg.UpdateProgress();
		myPrgDlg.UpdateProgressText(szLine1, szLine2);
	}
catch(e)
	{
		ExitScript(e);
	}	
	
} // End DisplayProgess()

function SetAccountsXMLPermission()
{
 try{
 		DisplayProgess(progLine1, "SetAccountsXMLPermission");
 		gLogStream.Write("\r\n*Setting permissions on ACCOUNTS.XML file");
 		
 		var xceleraPath = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{51D0666C-1CF7-4654-84A7-3576690BA2F1}\\InstallLocation");
 		if(fso.FileExists(xceleraPath + "\\Programs\\Accounts.XML" ) == false)
 		{	// Not created yet, so make an empty file
 			var newFile = fso.CreateTextFile(xceleraPath + "\\Programs\\Accounts.XML");
 			newFile.Close();
 			gLogStream.Write("\r\n*\tExisting ACCOUNTS.XML file not found, empty instance has been created.");
 		}
		
		var permissionsList = new Array	(
											new Array("S-1-5-32-544", "F"),	// Administrators, full access
											new Array("S-1-5-18", "F"),		// Local System (SERVICE acct.), full access
											new Array("S-1-5-32-545", "N")	// Users, no access
										);
		for(key in permissionsList)
		{
			var groupName = SidToName(permissionsList[key][0]); // Look it up
			var permType = permissionsList[key][1];
 		
			cmd_line = "%COMSPEC% /C CACLS.exe " + "\"" + xceleraPath + "\\Programs\\Accounts.XML\"" + " /E /C /P ";
	 		cmd_line += "\"" + groupName + "\":" + permType;
	
			gLogStream.Write("\r\n*\t" + cmd_line);	 		
			var ret_val = WSHShell.Run(cmd_line, 0, true);
			gLogStream.Write("\r\n***\treturn code from CACLS: " + ret_val + "\r\n*");
	 	}
   	}
 catch(e)
 	{
 		ExitScript("Error in SetAccountsXMLPermission(): " + e.description);
 	}
 	
} // End SetAccountsXMLPermission();

function SidToName(sidString)
{
 try{
 		gLogStream.Write("\r\n*\tSID -> " + sidString + " resolves to: ");

		var myLocalizer = new ActiveXObject("Localizer.SIDClass");
		var localName = myLocalizer.GetNameFromSID(sidString);
 		delete myLocalizer;
 		
 		if(!localName.length)
 			throw "Couldn't resolve SID: " + sidString + " to name !"; 
 			
 		gLogStream.Write(localName);	
		return localName;
	}
 catch(e)
 	{
 		ExitScript("SidToName() error:\n\n" + e.description);
 	}   		
} // End SidToName()

function QuestraUpdate(source_path)
{
 try {
 		DisplayProgess(progLine1, "QuestraUpdate");
		gLogStream.Write("\r\n*Preparing for Questra update...");

		var psaPath;
		try {
				psaPath = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\InstallShield_{013C4D9A-2658-4345-933C-B9361E5B8428}\\InstallLocation");
			}
		catch(e)
			{
				gLogStream.Write("\r\n*\tNo Questra Agent found, skipping update !");
				return; // OK, this may be a client
			}
		// Part 1: Copy the new files over existing
		gLogStream.Write("\r\n*Updating Questra XML files...");

		var szRootFolder = fso.GetFolder(source_path);
		var eFiles = new Enumerator(szRootFolder.files);
		for(; !eFiles.atEnd(); eFiles.moveNext())
		{
	  		var curFile = eFiles.item();
	  		if(fso.FileExists(psaPath + "etc\\templates\\" + curFile.Name) == true)
	  		{
	  			var installedFile = fso.GetFile(psaPath + "etc\\templates\\" + curFile.Name);
	  			installedFile.Attributes = 0; // Clear any flags
	  		}
	  		
	  		curFile.attributes = 0;
	  		curFile.Copy(psaPath + "etc\\templates\\" + curFile.Name, true);
		}			
		gLogStream.Write(" Done.");
		
		gLogStream.Write("\r\n*Updating SITEMAP.XML with HOSTNAME info...");
		// Part 2: Update the sitemap.xml with 'hostname'
		var WshNetwork = WScript.CreateObject("WScript.Network");
		var hostName = WshNetwork.ComputerName;
		var xmlFile = fso.GetFile(psaPath + "etc\\sitemap.xml");
		xmlFile.Attributes = 0; // Clear any read-only flag
		
		var myXML = new ActiveXObject("MSXML.DOMDocument");
		myXML.async = false;
		myXML.load(psaPath + "etc\\sitemap.xml");
		var myRoot = myXML.documentElement;
		
/*	Insert following fragment:
		<replace>
			<text symbol="__HOSTNAME__">hostname of system</text>
		</replace>
*/	
		var replaceElem = myXML.createElement("replace");
		myRoot.appendChild(replaceElem);
		var hostElem = myXML.createElement("text");
		hostElem.setAttribute("symbol", "__HOSTNAME__");
		replaceElem.appendChild(hostElem);
		var hostText = myXML.createTextNode(hostName);
		hostElem.appendChild(hostText);

		myXML.save(psaPath + "etc\\sitemap.xml");
		delete myXML;
		gLogStream.Write(" Done.");
		
		// Part 3: Run the update cmd
		gLogStream.Write("\r\n*Running the Questra update script...");
		cmd_line = "\"" + psaPath + "bin\\gencfg.cmd\" -template \"" + psaPath + "etc\\templates\" -cfgdir \"" + psaPath + "etc\""; 
		WSHShell.Run(cmd_line, 1, true);
		gLogStream.Write(" Done.");
   	}
 catch(e)
 	{
 		ExitScript("Error in QuestraUpdate(): " + e.description);
 	}
	
} // End QuestraUpdate()

function SetCWISresponseFile()
{
 try{
		gLogStream.Write("\r\n*Setting up CWIS.iss for un-install.");
		
		if(fso.FileExists(gRootFolderName + "\\UninstallIPSEC4Cwis.iss") == true)
		{
			var cwisFile = fso.GetFile(gRootFolderName + "\\UninstallIPSEC4Cwis.iss");
			cwisFile.Attributes = 0; // Clear read-only on source
			if(fso.FileExists("C:\\temp\\UninstallIPSEC4Cwis.iss") == true)	
			{
				cwisFile = fso.GetFile("C:\\temp\\UninstallIPSEC4Cwis.iss");
				cwisFile.Attributes = 0; // Clear read-only on target
			}
			fso.CopyFile(gRootFolderName + "\\UninstallIPSEC4Cwis.iss", "C:\\temp\\UninstallIPSEC4Cwis.iss", true);
			gLogStream.Write("\r\n*\tUninstallIPSEC4Cwis.iss copied in place for un-install.");
		}
		else
			gLogStream.Write("\r\n*\tUninstallIPSEC4Cwis.iss not found - CWIS un-install will fail !");
   	}
 catch(e)
 	{
 		ExitScript("Error in SetCWISresponseFile(): " + e.description);
 	}
 	
} // End SetCWISresponseFile();

function UpdateUltraSoundDB()
{
 try{
 		DisplayProgess(progLine1, "UpdateUltraSoundDB");
 		gLogStream.Write("\r\n* Looking for UltraSound DB...");
 		
 		try {
				var sqlPath = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Microsoft SQL Server\\MSSQL.1\\Setup\\SQLDataRoot");
			}
		catch(e)
			{
				gLogStream.Write("\r\n*\tSQL DB not found (nothing to do).");
				return;	// nothing to be done
			}
 		if(fso.FileExists(sqlPath + "\\EchoData.mdf") == false)
 		{
				gLogStream.Write("\r\n*\tUltraSound DB not found (nothing to do).");
				return;	// nothing to be done
		}
		
//		tbd. test if US update was OK first...
		var dbServerName = WSHShell.RegRead("HKLM\\SOFTWARE\\Philips\\Xcelera\\2.2.1\\Common\\Database Server");
		var dbInstanceName = WSHShell.RegRead("HKLM\\SOFTWARE\\Philips\\Xcelera\\2.2.1\\Common\\InstanceName");
		cmd_line = "\"" + gRootFolderName + "\\UltraSound\\ViewerUpdateUltrasound.bat\" ";
		cmd_line += dbServerName + "\\" + dbInstanceName + "," + dbServerName;
		DisplayProgess(progLine1, "Updating: UpdateUltraSoundDB()");
 		gLogStream.Write("\r\n* Updating UltraSound DB...");
 		gLogStream.Write("\r\n*\tCmd = " + cmd_line);
		WSHShell.Run("%COMSPEC% /C " + cmd_line, 2, true);
		gLogStream.Write("\r\n*\tUltraSound DB update completed.");
   	}
 catch(e)
 	{
 		ExitScript("Error in UpdateUltraSoundDB(): " + e.description);
 	}
 	
} // End UpdateUltraSoundDB();

function FillUninstallActions(actionList)
{
 try{
 		// Xcelera main
		gLogStream.Write("\r\n* Scanning for packages to uninstall...");

		var objIdx = 0;
		var uninstallList = new Array(
										new Array // PSA
										("InstallShield_{013C4D9A-2658-4345-933C-B9361E5B8428}", // guid
										 "setup.exe",
										 "setup.exe",
										 "-removeonly",
										 "013C4D9A-2658-4345-933C-B9361E5B8428"					// path
										),

										new Array	// MIP
										("{346172DB-4A26-49A0-AA27-59A3A133A0BC}", 
										 "msiexec.exe",
										 "",
										 "-X{346172DB-4A26-49A0-AA27-59A3A133A0BC}",
										 "346172DB-4A26-49A0-AA27-59A3A133A0BC"
										),
										
										new Array // CWIS
										("{601F761F-61F1-48B0-91A8-77CA1329766B}",
										 "setup.exe",
										 "setup.exe",
										 "-removeonly /s /f1\"C:\\temp\\UninstallIPSEC4Cwis.iss\"",
										 "601F761F-61F1-48B0-91A8-77CA1329766B"
										),
										
										new Array // Main
										("{9A340247-1F6C-49D4-ACBD-35B3A89101C0}",
										 "setup.exe", // cmd
										 "setup.exe", // tgt
										 "-uninst",
										 "9A340247-1F6C-49D4-ACBD-35B3A89101C0"
										)
									);
									
		for(key in uninstallList)
		{
			var listObj = uninstallList[key];

		 	try{
 				// Will throw if key doesn't exist (== package not installed)
				var szName = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\" + listObj[0] + "\\DisplayName");
				
				var launchObj = new Object();
				launchObj.name = szName;
				gLogStream.Write("\r\n*\r\n*\tname = " + launchObj.name);
				var szPath = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\ProgramFilesDir");
				launchObj.path = szPath + "\\InstallShield Installation Information\\{" + listObj[4] + "}";
				gLogStream.Write("\r\n*\tpath = " + launchObj.path);
				launchObj.cmd = listObj[1];
				gLogStream.Write("\r\n*\tcmd = " + launchObj.cmd);
				launchObj.target = listObj[2] ;
				gLogStream.Write("\r\n*\ttarget = " + launchObj.target);
				launchObj.guid = listObj[0];
				gLogStream.Write("\r\n*\tguid = " + launchObj.guid);
				launchObj.args = listObj[3];
				gLogStream.Write("\r\n*\targs = " + launchObj.args);
				launchObj.order = objIdx + 1;
				gLogStream.Write("\r\n*\torder = " + launchObj.order);
				launchObj.log = "";
				actionList[objIdx++] = launchObj;
			}
			catch(e) {} // do nothing, maybe not installed
		} // for()
   	}
 catch(e)
 	{
 		ExitScript("Error in FillUninstallActions(): " + e.description);
 	}
 	
} // End FillUninstallActions();

function ExecuteActions(actionList)
{
 try{
		// Execute list
		gLogStream.Write("\r\n*\r\n* Executing packages in sequence..."); 
		var bCancelFlag = false;
		
		if(bUninstallMode == true)
		{
			progLine1 = "Maintenance in progress... (please wait)";
			progLine2 = "Removing items";	
		}
		else
		{
			progLine1 = "Installation in progress... (please wait)"
			progLine2 =  "Installing items";
		}
		myPrgDlg.ShowProgressDialog(sTitle, progLine1, progLine2);
		
		for(key in actionList)
		{
			gLogStream.Write("\r\n*\r\n* Doing " + actionList[key].name);

			try {
					var installedItemRegPath = "HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\";
					installedItemRegPath += actionList[key].guid + "\\InstallLocation";
					WSHShell.RegRead(installedItemRegPath); // throws if not found
				}
			catch(e)
				{
					gLogStream.Write("\r\n*\t - component not found, skipping action !");
					continue;
				}
			if(actionList[key].cmd == "")
			{
				gLogStream.Write("\r\n*\t - no action defined, continuing !");
				continue;
			}
			
			if(actionList[key].target == "")
				cmd_line = "\"" + actionList[key].cmd + "\"";
			else
			if(actionList[key].cmd == actionList[key].target)
				cmd_line = "\"" + actionList[key].path + "\\" + actionList[key].cmd + "\"";
			else
				cmd_line = actionList[key].cmd + " " +  actionList[key].path + "\\" + actionList[key].target;
				
			cmd_line += " " + actionList[key].args;
			if( (bUninstallMode == false) && (bAutoClientMode == true) )
				cmd_line += " /au"; 		// Set autoupdate swith
			else
			if( (bUninstallMode == false) && (bClusterMode == true) )
				cmd_line += " /enterprise"; // Set cluster switch
				
			gLogStream.Write("\r\n*\r\n* Executing " + actionList[key].name + " - " + cmd_line);
			DisplayProgess(progLine1, "Executing: " + actionList[key].name);
				
			var oExec = WSHShell.Exec(cmd_line);
			while(oExec.Status == 0)
			{
				WScript.Sleep(2000);
				myPrgDlg.UpdateProgress();
				bCancelFlag = myPrgDlg.GetCancelStatus();
			}
			gLogStream.Write("\r\n* Return code: " + oExec.ExitCode);
			if(bCancelFlag == true)
			{
				ExitScript("User cancelled installation !");
			}
			if(actionList[key].log != "")
				CheckLogFile(actionList[key].log);
		}
	}
catch(e)
	{
		ExitScript("Error in ExecuteActions(): " + e.description);
	}
	
} // End ExecuteActions()

function CopyScriptForUninstall()
{
 try{
 		gLogStream.Write("\r\n* Copying installer script for uninstall... ");
 		DisplayProgess(progLine1, "CopyScriptForUninstall");
 		
 		var uninstPath = WSHShell.RegRead("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{9A340247-1F6C-49D4-ACBD-35B3A89101C0}\\InstallSource");
 		if(fso.FileExists(uninstPath + "\\" + WScript.ScriptName) == true)
 		{	// Clear any read-only flag
 			var scriptFile = fso.GetFile(uninstPath + "\\" + WScript.ScriptName);
 			scriptFile.Attributes = 0; 
 		}
 		fso.CopyFile(gRootFolderName + "\\" + WScript.ScriptName, uninstPath + "\\" + WScript.ScriptName, true);
 		WSHShell.RegWrite("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{9A340247-1F6C-49D4-ACBD-35B3A89101C0}\\UninstallString", "cscript.exe //E:javascript \"" + uninstPath + "\\" + WScript.ScriptName + "\" -u", "REG_SZ");
 		gLogStream.Write("Done.");
 		
 		// For un-install
 		gLogStream.Write("\r\n* Copying utilities for uninstall... ");

 		for(key in utilList)
 		{
	 		if(fso.FileExists(uninstPath + "\\" + utilList[key]) == true)
	 		{	// Clear any read-only flag
	 			var progressFile = fso.GetFile(uninstPath + "\\" + utilList[key]);
	 			progressFile.Attributes = 0; 
	 		}
	 		fso.CopyFile(gRootFolderName + "\\Utility\\" + utilList[key], uninstPath + "\\" + utilList[key], true);
			WSHShell.Run("%COMSPEC% /C regsvr32 /s \"" + uninstPath + "\\" + utilList[key] + "\"", 0, true);
	 		gLogStream.Write("\r\n*\t Registered - " + uninstPath + "\\" + utilList[key]);
		}
 		gLogStream.Write("\r\n* Done.");
 		
 		gLogStream.Write("\r\n* Copying CWIS answer file for uninstall... ");
 		if(fso.FileExists(uninstPath + "\\UninstallIPSEC4Cwis.iss") == true)
 		{	// Clear any read-only flag
 			var answerFile = fso.GetFile(uninstPath + "\\UninstallIPSEC4Cwis.iss");
 			answerFile.Attributes = 0; 
 		}
 		fso.CopyFile(gRootFolderName + "\\Utility\\UninstallIPSEC4Cwis.iss", uninstPath + "\\UninstallIPSEC4Cwis.iss", true);
 		gLogStream.Write("Done.");
   	}
 catch(e)
 	{
 		ExitScript("Error in CopyScriptForUninstall(): " + e.description);
 	}
 	
} // End CopyScriptForUninstall();
	
function CheckInstalledVersion()
{
 try{	
 		gLogStream.Write("\r\n*\r\n* Checking installed Xcelera version...")
 		var szVersion = WSHShell.RegRead("HKLM\\SOFTWARE\\Philips\\Xcelera\\CurrentVersion");
 		if(szVersion.lastIndexOf("2.2.1") == -1)
 		{
 			gLogStream.Write("\r\n*\tIncorrect version detected: " + szVersion);
 			throw "version error";
 		}
 		gLogStream.Write("\r\n*\tFound version: " + szVersion);
   	}
 catch(e)
 	{
 		ExitScript("Problem locating existing Xcelera 2.2 installation\r\n\r\nThis service pack installation can't continue.\r\n(no changes have been applied)");
 	}
 	
} // End CheckInstalledVersion();

function ReWriteUninstallInfo()
{
 try{
 		DisplayProgess(progLine1, "ReWriteUninstallInfo");
		gLogStream.Write("\r\n*\r\n* Applying signature data to registry key:");
		gLogStream.Write("\r\n*\tHKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{9A340247-1F6C-49D4-ACBD-35B3A89101C0}\\DisplayVersion");
 		WSHShell.RegWrite("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{9A340247-1F6C-49D4-ACBD-35B3A89101C0}\\DisplayName", "Xcelera Main 2.2L1 SP1", "REG_SZ");
 		gLogStream.Write("\r\n* Registry update completed.");
 	}
 catch(e)
 	{
 		ExitScript("ReWriteUninstallInfo() error:\n\n" + e.description);
 	}   		
} // End ReWriteUninstallInfo()

function sortFunc(objItem1, objItem2)
{
 try{	
 		// Shouldn't be the same
 		if(objItem1.order == objItem2.order)
 			ExitScript("Conflicting launch sequence detected:\r\n" + objItem1.name + "\r\n" + objItem2.name + "\r\n - both set to value " + objItem1.order);
 		// .GT.
 		if(objItem1.order > objItem2.order)
 			return 1;
 		// .LT.
 		return -1;
   	}
 catch(e)
 	{
 		ExitScript("Error in sortFunc(): " + e.description);
 	}
 	
} // End sortFunc();

function ScanActions(toDoList)
{
 try{
		gLogStream.Write("\r\n* Scanning for installation packages...");

 		var foundIdx = 0;
 		var curFolder = fso.GetFolder(gRootFolderName);
 		var eSub = new Enumerator(curFolder.SubFolders);
   		for(; !eSub.atEnd(); eSub.moveNext())
		{
  			var curSub = eSub.item();
			gLogStream.Write("\r\n*\r\n* Found component folder: " + curSub.Name);

  			if(fso.FileExists(curSub + "\\install.xml") == false)
  			{
  				gLogStream.Write("\r\n* Control file 'install.xml' not found in subfolder " + curSub.Name);
  				gLogStream.Write("\r\n*\t- this component will not be installed !");
  				continue;
  			}
  			var myXML = new ActiveXObject("MSXML.DOMDocument");
  			myXML.async = false;
			myXML.load(curSub + "\\install.xml");
			
			// Store the retrieved data
			var launchObj = new Object();
			launchObj.path = curSub.Path;
			gLogStream.Write("\r\n*\tpath = " + launchObj.path);
			launchObj.name = getXMLElement(myXML, "name");
			gLogStream.Write("\r\n*\tname = " + launchObj.name);
			launchObj.cmd = getXMLElement(myXML, "launch");
			gLogStream.Write("\r\n*\tcmd = " + launchObj.cmd);
			launchObj.target = getXMLElement(myXML, "target");
			gLogStream.Write("\r\n*\ttarget = " + launchObj.target);
			launchObj.guid = getXMLElement(myXML, "GUID");
			gLogStream.Write("\r\n*\tguid = " + launchObj.guid);
			launchObj.log = getXMLElement(myXML, "logfile");
			gLogStream.Write("\r\n*\tlogfile = " + launchObj.log);
			launchObj.args = getXMLElement(myXML, "args");
			gLogStream.Write("\r\n*\targs = " + launchObj.args);
			launchObj.order = getXMLElement(myXML, "sequence");
			gLogStream.Write("\r\n*\torder = " + launchObj.order);
			toDoList[foundIdx++] = launchObj;
			
			delete myXML;
    	}
 	}
 catch(e)
 	{
 		ExitScript("Error in ScanActions(): " + e.description);
 	}
 	
} // End ScanActions();

function getXMLElement(xmlDoc, elementName)
{
 try{
 		var itemValue = xmlDoc.getElementsByTagName(elementName);
 		if(itemValue.length)
 			return itemValue[0].text;
 		
 		return "";
 	}
 catch(e)
 	{
 		ExitScript("Error in getXMLElement(): " + elementName);
 	}
} // End getXMLElement()


function GetWorkingFolder()
{
try{
	var curFolder = WScript.ScriptFullName;
	var curName = 	WScript.ScriptName;
		
	var nFolderLength = curFolder.length - curName.length;
	return curFolder.substr(0, nFolderLength - 1);
	}
catch(e)
	{
		ExitScript("Error in GetWorkingFolder()" + e.description);
	}
	
} // End GetWorkingFolder()

function CreateLogFile()
{
try {
		var logDate = new Date();
		gLogName = fso.GetSpecialFolder(2).Path;
		gLogName += "\\" + sTitle + "_" + logDate.getDate() + "-";
		gLogName += (logDate.getMonth()+ 1) + "-" + logDate.getYear(); 
		gLogName += "_" + logDate.getHours() + "_" + logDate.getMinutes() + "_" + logDate.getSeconds();
		gLogName += ".txt";
		
		if(fso.FileExists(gLogName) == true)
		{
			fso.DeleteFile(gLogName);
		}
		gLogStream = fso.CreateTextFile(gLogName, true, true); // UNICODE for MIT00031383

		gLogStream.Write("============= Session Start =============\r\n*");
		gLogStream.Write("\r\n* " + sTitle);
		gLogStream.Write("\r\n* for BU HI-CAI QV224");
		gLogStream.Write("\r\n*\r\n* Started: " + logDate.toLocaleString());
		gLogStream.Write("\r\n*\r\n*");
	}
catch(e)
	{
		WSHShell.Popup("Could'nt create log file: \n" + gLogName, 6, sTitle, 48);
		WScript.Quit(1);
	}	
} // End CreategLogFile()

function ExitScript(mesg)
{
	if(myPrgDlg != null)
	{
		myPrgDlg.RemoveProgressDialog();
		delete myPrgDlg;
	}

	var logDate = new Date();
	if(mesg != "")
	{
		gLogStream.Write("\r\n*\r\n*");
		gLogStream.Write("\r\n** Error: " + mesg + " **");
	}

	gLogStream.Write("\r\n*\r\n* Finished: " + logDate.toLocaleString());
	gLogStream.Write("\r\n*\r\n============= Session End ===============");
	gLogStream.Close();
	
	var err_code = 0;	// No error
	if(mesg != "")
	{
		WSHShell.Popup("Exit on error:\n\n" + mesg + "\n\n(Click OK to open the log file)", 0, sTitle, 0 + 48); // OK, Exclamation mark
		WSHShell.Run("notepad.exe " + gLogName, 1, false);
		err_code = 1;	// Is in error
	}
	else
	{
		var ret_val = WSHShell.Popup("SP1 update completed !\n\nDo you wish to view the log file ?", 0, sTitle, 4 + 32); // yes, no
		if(ret_val == 6)
			WSHShell.Run("notepad.exe " + gLogName, 1, false);
	}
		
	WScript.Sleep(4000);// Give Notepad time to start
	DetermineReboot(); 	// If necessary
	
	WScript.Quit(err_code);
	
} // End ExitScript(mesg)