Subversion Repositories spk

#include "OriginalFiles.h"

#include "File.h"

#include "Logging/Log.h"

#include "BaseFile.h"

#include "spk.h"

//#include "ProgressInfo.h"

namespace SPK {

void AddLogEntry(int type, CyString args, CyStringList *errors)

{

	if ( errors ) errors->PushBack(args, ERRORLOG(type));

}

COriginalFiles::COriginalFiles(const Utils::String &dir) : _sDir(dir)

{

}

COriginalFiles::~COriginalFiles(void)

{

	reset();

}

int COriginalFiles::count() const

{

	return _lFiles.size();

}

/**

 * Check for original file

 *

 * Checks if the file is an original file or not

 */

bool COriginalFiles::isOriginal(C_File *f) const

{

	if ( _getFile(f) )

		return true;

	return false;

}

void COriginalFiles::backup(CBaseFile *package, CyStringList *errors)

{

	// backup any original files before installing

	CLog::log(CLog::Log_Install, 3, "Checking for any original files to backup");

	CDirIO oDir(_sDir + "/PluginManager/Original");

	for ( CListNode<C_File> *oNode = _lFiles.Front(); oNode; oNode = oNode->next() )

	{

		C_File *of = oNode->Data();

		for ( CListNode<C_File> *checkNode = package->GetFileList()->Front(); checkNode; checkNode = checkNode->next() )

		{

			C_File *f = checkNode->Data();

			// match the same filetype

			if ( of->GetFileType() != f->GetFileType() )

				continue;

			// same file

			if ( of->GetFilename().Compare(f->GetFilename()) )

			{

				// check if original file already exists (assume already backed up)

				if ( !backupFile(of, errors) )

					continue;

				break;

			}

		}

	}

}

bool COriginalFiles::backupFile(C_File *f, CyStringList *errors)

{

	Utils::String newDir = "PluginManager/Original/" + f->GetDirectory(NULL).ToString();

	CDirIO oDir(_sDir);

	if ( oDir.Exists(newDir + "/" + f->GetFilename().ToString()) )

		return true;

	// make sure the directory exissts

	if ( !oDir.Exists(newDir) )

	{

		if ( !oDir.Create(newDir) )

		{

			CLog::logf(CLog::Log_Install, 2, "Unable to create directory to backup original files, %s", newDir.c_str());

			AddLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, newDir, errors);

			return false;

		}

		CLog::logf(CLog::Log_Install, 2, "Created new directory, %s", newDir.c_str());

		AddLogEntry(SPKINSTALL_CREATEDIRECTORY, newDir, errors);

	}

	// now lets copy the file

	CFileIO CopyFile(f->GetFilePointer());

	if ( CopyFile.copy(oDir.File(newDir + "/" + f->GetFilename().ToString()).ToString()) )

	{

		CLog::logf(CLog::Log_Install, 2, "Original file: %s has been backed up", f->GetNameDirectory(NULL).c_str());

		AddLogEntry(SPKINSTALL_ORIGINAL_BACKUP, f->GetNameDirectory(NULL), errors);

		return true;

	}

	else

	{

		CLog::logf(CLog::Log_Install, 2, "Failed to backup the original file: %s", f->GetNameDirectory(NULL).c_str());

		AddLogEntry(SPKINSTALL_ORIGINAL_BACKUP_FAIL, f->GetNameDirectory(NULL), errors);

		return false;

	}

}

bool COriginalFiles::doBackup(C_File *f, CyStringList *errors)

{

	bool backed = false;

	C_File *of = this->_getFile(f);

	if ( of ) {

		// check if the orignal file is already backed up

		if ( !CFileIO::Exists(_sDir + "/PluginManager/Original/" + f->GetNameDirectory(NULL).ToString()) )

		{

			// lets back up the file now

			backed = this->backupFile(of, errors);

		}

	}

	return backed;

}

int COriginalFiles::restoreAll(CProgressInfo *info, int files, int max)

{

	for ( CListNode<C_File> *oNode = _lFiles.Front(); oNode; oNode = oNode->next() )

	{

		// update the progress

		if ( info ) info->UpdateProgress(files, max);

		++files;

		C_File *f = oNode->Data();

		CFileIO of(_sDir + "/PluginManager/Original/" + f->GetNameDirectory(NULL).ToString());

		if ( of.exists() )

			of.Rename(_sDir + "/" + f->GetNameDirectory(NULL).ToString());

		delete oNode->Data();

	}

	_lFiles.clear();

	return files;

}

bool COriginalFiles::restoreFile(C_File *f, CyStringList *errors)

{

	bool original = false;

	// check if its an original file and restore

	if ( this->isOriginal(f) )

	{

		CFileIO of(_sDir + "/PluginManager/Original/" + f->GetNameDirectory(NULL).ToString());

		if ( of.exists() )

		{

			original = true;

			if ( of.Rename(_sDir + "/" + f->GetNameDirectory(NULL).ToString()) )

				AddLogEntry(SPKINSTALL_ORIGINAL_RESTORE, f->GetNameDirectory(NULL), errors);

			else

				AddLogEntry(SPKINSTALL_ORIGINAL_RESTORE_FAIL, f->GetNameDirectory(NULL), errors);

		}

	}

	return original;

}

void COriginalFiles::parse(const Utils::String &data)

{

	C_File *uf = new C_File();

	uf->SetFileType(data.token(" ", 1).toLong());

	// Extra files also contain a directory, so make sure we split that up

	if ( uf->GetFileType() == FILETYPE_EXTRA )

	{

		uf->SetDir(data.tokens(" ", 2).tokens(":", 2));

		uf->SetFilename(data.tokens(" ", 2).token(":", 1));

	}

	else

		uf->SetFilename(data.tokens(" ", 2));

	// set the complete filename, GetNameDirectory returns the directory based on the file type

	uf->SetFilename(_sDir + "/" + uf->GetNameDirectory(NULL).ToString());

	_lFiles.push_back(uf);

}

void COriginalFiles::update(bool bForce, const CLinkList<C_File> *pFiles)

{

	if ( _lFiles.empty() || bForce )

	{

		_storeFiles(FILETYPE_SCRIPT, "scripts", pFiles);

		_storeFiles(FILETYPE_TEXT, "t", pFiles);

		_storeFiles(FILETYPE_SOUND, "soundtrack", pFiles);

		_storeFiles(FILETYPE_EXTRA, "mov", pFiles);

	}

}

bool COriginalFiles::writeData(CyStringList *lines)

{

	bool addAny = false;

	if ( !_lFiles.empty() )

	{

		for ( CListNode<C_File> *node = _lFiles.Front(); node; node = node->next() )

		{

			C_File *uf = node->Data();

			Utils::String uString = "Original: ";

			uString += Utils::String::Number((long)uf->GetFileType()) + " ";

			uString += uf->GetFilename().ToString();

			// add the directory for Extra files

			if ( uf->GetFileType() == FILETYPE_EXTRA && !uf->GetDir().Empty())

			{

				uString += ":";

				uString += uf->GetDir().ToString();

			}

			lines->PushBack(CyString(uString));

			addAny = true;

		}

	}

	return addAny;

}

void COriginalFiles::reset()

{

	_lFiles.MemoryClear();

}

/**

 * Update original files list

 *

 * Scan the current directory for any fiels that are already there, ie ones that have not been installed

 * Original files should be all the scripts/sounds, etc that are in an unmodified game directory

 *

 * Save list of files and check if any packages overright these files

 * Any file that gets overrighten from this list will automatically be backed up, and restored once the packages are removed

 */

void COriginalFiles::_storeFiles(int filetype, const Utils::String &searchPath, const CLinkList<C_File> *pFiles)

{

	Utils::String ext = "pck";

	switch ( filetype )

	{

		case FILETYPE_SOUND:

			ext = "mp3";

			break;

	}

	CDirIO Dir(_sDir + "/" + searchPath);

	CyStringList *files = Dir.DirList();

	if ( !files )

		return;

	for ( SStringList *node = files->Head(); node; node = node->next )

	{

		CFileIO File(Dir.File(node->str));

		if ( File.extension().Compare(ext) )

			_add(filetype, File.filename(), searchPath, pFiles);

	}

	delete files;

}

/**

 * Get original file

 *

 * Finds a matching original file entry and returns it

 */

C_File *COriginalFiles::_getFile(C_File *file) const

{

	if ( !file ) return NULL;

	for ( CListNode<C_File> *node = _lFiles.Front(); node; node = node->next() )

	{

		C_File *of = node->Data();

		// not of the same file type

		if ( of->GetFileType() != file->GetFileType() )

			continue;

		// same file name, must be the same file

		if ( of->GetFilename().Compare(file->GetFilename()) )

			return of;

	}

	return NULL;

}

/**

 * Adds a file onto the original files list

 *

 * Checks if it already exists so we dont create multiples

 */

void COriginalFiles::_add(int filetype, const Utils::String &filename, const Utils::String &searchPath, const CLinkList<C_File> *pFiles)

{

	// dont add plugin manager as original files

	if ( filetype == FILETYPE_SCRIPT && filename.isin("!init.pmanager") )

		return;

	// first check if a matching one exists

	for ( CListNode<C_File> *node = _lFiles.Front(); node; node = node->next() )

	{

		C_File *file = node->Data();

		if ( file->GetFileType() != filetype )

			continue;

		if ( file->GetFilename().Compare(CyString(filename)) )

			return;

	}

	// check that no packages are currently using them either, not original if being used already

	for ( CListNode<C_File> *node = pFiles->Front(); node; node = node->next() )

	{

		C_File *file = node->Data();

		if ( file->GetFileType() != filetype )

			continue;

		if ( file->GetFilename().Compare(CyString(filename)) )

			return;

	}

	// add the file entry to the list

	C_File *of = new C_File(CyString(filename));

	of->SetFileType(filetype);

	if ( filetype == FILETYPE_EXTRA )

		of->SetDir(searchPath);

	of->SetFilename(_sDir + "/" + of->GetNameDirectory(NULL).ToString());

	_lFiles.push_back(of);

}

}