public static InstalledPackage InstallLocalPackage(string packagePath, string projectPath, string _namespace, out LogDataList log, bool ignoreClash = false, bool alreadyCopiedToTemp = false, bool procEvents = true)
{
if (string.IsNullOrWhiteSpace(projectPath))
{
try
{
throw new ArgumentNullException(ExceptionMessages.General.PROJ_PATH_ARG_NULL);
}
catch (Exception ex)
{
Logger.WriteErrorLog(InstallerMessages.Error.UNABLE_OPEN_LOCAL_PACKAGE_NULL, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
log = new LogDataList();
ProjectPackMan openedProject = null;
LogDataList outLog = null;
try
{
openedProject = new ProjectPackMan(projectPath, _namespace, out outLog);
}
catch (Exception ex)
{
Logger.WriteErrorLog(InstallerMessages.Error.UNABLE_OPEN_LOCAL_PACKAGE + projectPath + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
InstalledPackage retVal = InstallLocalPackage(packagePath, openedProject, _namespace, out outLog, ignoreClash, alreadyCopiedToTemp, procEvents);
log.AppendLogs(outLog);
return(retVal);
}
public static void ReinstallLocalPackage(string UID, ProjectPackMan openProject, string _namespace, out LogDataList log)
{
if (openProject == null || openProject.InstalledPackages == null)
{
try
{
throw new InstalledPackageNotFoundException(ExceptionMessages.General.PackWIDNotFound(UID));
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.PackageMissng(UID), _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
InstalledPackage foundInstalledPackage = openProject.InstalledPackages.FindByUID(UID);
if (foundInstalledPackage == null)
{
try
{
throw new InstalledPackageNotFoundException(ExceptionMessages.General.PackWIDNotFound(UID));
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.PackageMissng(UID), _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
ReinstallLocalPackage(foundInstalledPackage, openProject, _namespace, out log);
}
public static InstalledPackage UpdateLocalPackage(string pathToInstaller, string pathToProject, bool packageAlreadyCopiedToTem, string _namespace, out LogDataList log, bool skipInstallFileExistenceCheck = false)
{
if (string.IsNullOrWhiteSpace(pathToProject))
{
try
{
throw new ArgumentNullException(ExceptionMessages.General.PROJ_PATH_ARG_NULL);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Uninstaller.Error.UNABLE_OPEN_LOCAL_PACKAGE_NULL, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
log = new LogDataList();
LogDataList outLog = null;
ProjectPackMan openedProject = null;
try
{
openedProject = new ProjectPackMan(pathToProject, _namespace, out outLog);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Uninstaller.Error.UNABLE_OPEN_LOCAL_PACKAGE + pathToProject + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
InstalledPackage retVal = UpdateLocalPackage(pathToInstaller, openedProject, packageAlreadyCopiedToTem, _namespace, out outLog, skipInstallFileExistenceCheck);
log.AppendLogs(outLog);
return(retVal);
}
public static void ReinstallLocalPackage(string UID, string projectPath, string _namespace, out LogDataList log)
{
if (File.Exists(projectPath))
{
projectPath = Path.GetDirectoryName(projectPath);
}
if (!Directory.Exists(projectPath))
{
try
{
throw new DirectoryNotFoundException(projectPath + ExceptionMessages.General.COULD_NOT_BE_FOUND);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.OpenProjNullOrMiss(projectPath), _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
log = new LogDataList();
ProjectPackMan openedProject = null;
LogDataList outLog = null;
try
{
openedProject = new ProjectPackMan(projectPath, _namespace, out outLog);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.LOAD_FAILED_PROJ + projectPath + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
ReinstallLocalPackage(UID, openedProject, _namespace, out outLog);
log.AppendLogs(outLog);
}
public static void UninstallLocalPackage(string projectPath, string arg, string _namespace, out LogDataList log, UninstallArgType argType = UninstallArgType.UID, bool deleteInstallFiles = true, bool procEvents = true)
{
if (string.IsNullOrWhiteSpace(projectPath))
{
try
{
throw new ArgumentNullException(ExceptionMessages.General.PROJ_PATH_ARG_NULL);
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.UNABLE_OPEN_LOCAL_PACKAGE_NULL, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
log = new LogDataList();
LogDataList outLog = null;
ProjectPackMan openedProject = null;
try
{
openedProject = new ProjectPackMan(projectPath, _namespace, out outLog);
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.UNABLE_OPEN_LOCAL_PACKAGE + projectPath + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
try
{
UninstallLocalPackage(openedProject, arg, _namespace, out outLog, argType, deleteInstallFiles, procEvents);
}
catch
{
throw;
}
log.AppendLogs(outLog);
}
public static void ReinstallLocalPackage(InstalledPackage installedPackage, ProjectPackMan openProject, string _namespace, out LogDataList log)
{
log = new LogDataList();
Logger.WriteInformationLog(LoggerMessages.PackageManagement.Reinstaller.Information.REINSTALL_PACKAGE_START_L, _namespace);
Exception outEx;
if (openProject == null || !Directory.Exists(openProject.DirectoryPath))
{
try
{
throw new DirectoryNotFoundException(ExceptionMessages.General.OPEN_PROJ_ARG_OR_DIRPATH_NULL);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.OpenProjNullOrMiss(openProject.DirectoryPath), _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
if (installedPackage == null || string.IsNullOrWhiteSpace(installedPackage.ArchivePath) || !File.Exists(installedPackage.ArchivePath))
{
try
{
throw new FileNotFoundException(ExceptionMessages.PackageManagement.Reinstaller.ARCH_INSTALL_FILE_NOT_FOUND);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.ARCH_NOT_FOUND, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
if (Helper.DeleteFolderSafely(PMFileSystem.PackMan_TempInstall, _namespace, out outEx, LoggerMessages.GeneralError.UNABLE_DELETE_TEMP_DIR_ARG) == DeleteFolderResult.UserCancelled)
{
throw outEx;
}
if (Helper.CreateFolderSafely(PMFileSystem.PackMan_TempInstall, _namespace, out outEx, LoggerMessages.GeneralError.UNABLE_CREATE_TEMP_DIR_ARG) == CreateFolderResult.UserCancelled)
{
throw outEx;
}
if (OnReinstallBegin != null)
{
OnReinstallBegin.Invoke(installedPackage, false, openProject);
}
try
{
ArchiveManagement.ExtractZip(installedPackage.ArchivePath, PMFileSystem.PackMan_TempInstall, _namespace);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.UNABLE_EXTRACT_ARCH + PMFileSystem.PackMan_TempInstall + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
LogDataList outLog = null;
try
{
Uninstaller.UninstallLocalPackage(openProject, installedPackage.Namespace, _namespace, out outLog, procEvents: false);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.UNABLE_UNINSTALL, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
InstalledPackage retVal = null;
try
{
retVal = Installer.InstallLocalPackage(PMFileSystem.PackMan_TempInstall + "\\" + Vars.INSTALL_FILE_DEFAULT_FILENAME, openProject, _namespace, out outLog, true, true);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Reinstaller.Error.UNABLE_INSTALL, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
if (OnReinstallDone != null)
{
OnReinstallDone.Invoke(retVal, false, openProject);
}
Logger.WriteInformationLog(LoggerMessages.PackageManagement.Reinstaller.Information.REINSTALL_PACKAGE_DONE_L, _namespace);
}
public static void UninstallLocalPackage(ProjectPackMan openProject, string arg, string _namespace, out LogDataList log, UninstallArgType argType = UninstallArgType.UID, bool deleteInstallFiles = true, bool procEvents = true)
{
log = new LogDataList();
Logger.WriteInformationLog(UninstallerMessages.Information.UNINSTALL_PACKAGE_START_L, _namespace);
Exception outEx;
if (string.IsNullOrWhiteSpace(arg))
{
try
{
throw new ArgumentNullException(ExceptionMessages.General.ARG_ARG_NULL);
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.ARG_INVALID, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
if (argType == UninstallArgType.DirectoryPath)
{
arg += "\\" + Vars.INSTALLED_XML_FILENAME;
}
if ((argType == UninstallArgType.XMLPath || argType == UninstallArgType.DirectoryPath) && !File.Exists(arg))
{
try
{
throw new FileNotFoundException(ExceptionMessages.PackageManagement.Uninstaller.INSTALL_SCRIPT_FILE_NOT_FOUND + arg + ".");
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.XML_FILE_NOT_FOUND + arg + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
LogDataList outLog;
if (openProject.InstalledPackages != null)
{
InstalledPackage installedPackage;
if (argType == UninstallArgType.XMLPath || argType == UninstallArgType.DirectoryPath)
{
installedPackage = openProject.InstalledPackages.FindByPath(arg);
}
else
{
installedPackage = openProject.InstalledPackages.FindByUID(arg);
}
if (installedPackage != null)
{
if (installedPackage.Package != null)
{
if (procEvents && OnPackageUninstallBegin != null)
{
OnPackageUninstallBegin.Invoke(installedPackage.Package, false, installedPackage.Directory, installedPackage, openProject);
}
UninstallPackage(installedPackage.Package, _namespace, out outLog, false, openProject.DirectoryPath);
if (outLog != null)
{
log.Logs.AddRange(outLog.Logs);
}
if (procEvents && OnPackageUninstalled != null)
{
OnPackageUninstalled.Invoke(installedPackage.Package, false, installedPackage, openProject);
}
}
else
{
ProcDelNonReadXMLPackage(arg, installedPackage.Directory, installedPackage, openProject, _namespace, out outLog, procEvents, argType, false, openProject.DirectoryPath);
if (outLog != null)
{
log.Logs.AddRange(outLog.Logs);
}
}
if (deleteInstallFiles)
{
if (Directory.Exists(installedPackage.Directory))
{
Helper.DeleteFolderSafely(installedPackage.Directory, _namespace, out outEx, new DeleteFolderLogMessages(deleteFailed: UninstallerMessages.Warning.DirectoryUnableDelete, logGroup: log));
}
openProject.InstalledPackages.Remove(installedPackage);
}
//else
//{
// if (installedPackage.Package != null)
// {
// installedPackage.Installed = false;
// try
// {
// installedPackage.Package.SaveToFile(installedPackage.XMLPath, _namespace, RMPackage.SaveToFileMode.ExplicitAssetInfo);
// }
// catch (Exception ex)
// {
// log.DataList.Add(new RMLogDataWarning(UninstallerMessages.Warning.InstalledXMLUpdateFailedInsStatus(installedPackage.XMLPath), _namespace, ex));
// throw;
// }
// }
//}
}
else
{
if (argType == UninstallArgType.UID)
{
try
{
throw new PackageNotFoundException(true, ExceptionMessages.General.PackWIDNotFound(arg));
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.PACKAGE_UID_NOT_FOUND + arg + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
string installedDir = null;
try
{
installedDir = Path.GetDirectoryName(arg);
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.INVALID_XML_PATH + arg + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
ProcDelNonReadXMLPackage(arg, installedDir, null, openProject, _namespace, out outLog, procEvents, argType, false, openProject.DirectoryPath);
}
}
else
{
if (argType == UninstallArgType.UID)
{
try
{
throw new PackageNotFoundException(true, ExceptionMessages.General.PackWIDNotFound(arg));
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.PACKAGE_UID_NOT_FOUND + arg + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
string installedDir = null;
try
{
installedDir = Path.GetDirectoryName(arg);
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.INVALID_XML_PATH + arg + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
ProcDelNonReadXMLPackage(arg, installedDir, null, openProject, _namespace, out outLog, procEvents, argType, false, openProject.DirectoryPath);
}
Logger.WriteInformationLog(UninstallerMessages.Information.UNINSTALL_PACKAGE_DONE_L, _namespace);
}
static UninstallResult ProcDelNonReadXMLPackage(string arg, string installedDir, InstalledPackage installedPackage, ProjectPackMan openedProject, string _namespace, out LogDataList log, bool procEvents = true, UninstallArgType argType = UninstallArgType.UID, bool globalPackage = true, string whereToRemove = null)
{
log = new LogDataList();
if (argType == UninstallArgType.DirectoryPath || argType == UninstallArgType.XMLPath)
{
LogDataList outLog = null;
RMPackage package = null;
if (procEvents && OnPackageUninstallBegin != null)
{
OnPackageUninstallBegin.Invoke(package, globalPackage, installedDir, installedPackage, openedProject);
}
RMPackage parsedPackage = null;
try
{
parsedPackage = new RMPackage(arg, _namespace, out outLog);
}
catch (Exception ex)
{
log.AppendLogs(outLog);
Logger.WriteErrorLog(UninstallerMessages.Error.XML_FILE_INVALID + arg + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
UninstallResult res = UninstallPackage(parsedPackage, _namespace, out outLog, globalPackage, whereToRemove);
log.AppendLogs(outLog);
if (procEvents && OnPackageUninstalled != null)
{
OnPackageUninstalled.Invoke(package, globalPackage, installedPackage, openedProject);
}
return(res);
}
else
{
try
{
throw new InvalidArgumentException(argType.GetType(), "argType");
}
catch (Exception ex)
{
Logger.WriteErrorLog(UninstallerMessages.Error.INVALID_PROCDELNONREADXMLPACKAGE_ARG, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
}
public static InstalledPackage InstallLocalPackage(string packagePath, ProjectPackMan openProject, string _namespace, out LogDataList log, bool ignoreClash = false, bool alreadyCopiedToTemp = false, bool procEvents = true, bool skipFileExistenceCheck = false)
{
log = new LogDataList();
if (string.IsNullOrWhiteSpace(packagePath))
{
try
{
throw new ArgumentNullException(ExceptionMessages.General.PACK_PATH_ARG_NULL);
}
catch (Exception ex)
{
Logger.WriteErrorLog(InstallerMessages.Error.PACKAGE_PATH_NULL, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
if (openProject == null || string.IsNullOrWhiteSpace(openProject.DirectoryPath))
{
try
{
throw new ArgumentException(ExceptionMessages.General.OPEN_PROJ_ARG_OR_DIRPATH_NULL);
}
catch (Exception ex)
{
Logger.WriteErrorLog(InstallerMessages.Error.NO_OPEN_PROJECT, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
Logger.WriteInformationLog(InstallerMessages.Information.PACKAGE_INSTALL_START_L + packagePath + ".", _namespace);
Exception outEx;
LogDataList outLog = null;
string oldPackagePath = packagePath;
try
{
if (!alreadyCopiedToTemp)
{
packagePath = InitPackageInstaller(packagePath, false, _namespace, out outLog);
}
}
catch (Exception ex)
{
Logger.WriteErrorLog(InstallerMessages.Error.INIT_ERROR + packagePath + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
if (procEvents)
{
CleanupTempInstallDir(_namespace, false);
}
throw;
}
log.AppendLogs(outLog);
RMPackage package = null;
try
{
package = new RMPackage(packagePath, _namespace, out outLog);
}
catch (Exception ex)
{
log.AppendLogs(outLog);
Logger.WriteErrorLog(InstallerMessages.Error.XML_READ_ERROR + packagePath + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
if (procEvents)
{
CleanupTempInstallDir(_namespace, false);
}
throw;
}
log.AppendLogs(outLog);
if (!skipFileExistenceCheck)
{
PerformPackageFilesExistenceCheck(package, _namespace, out outLog);
if (outLog != null)
{
log.Logs.AddRange(outLog.Logs);
}
}
if (!ignoreClash && openProject.InstalledPackages.FindByUID(package.UniqueID) != null)
{
try
{
throw new PackageAlreadyExistsException(ExceptionMessages.General.PackWIDExists(package.UniqueID));
}
catch (Exception ex)
{
Logger.WriteErrorLog(InstallerMessages.Error.PACKAGE_ALREADY_EXISTS, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
if (procEvents)
{
CleanupTempInstallDir(_namespace, false);
}
throw;
}
}
if (procEvents && OnPackageInstallBegin != null)
{
OnPackageInstallBegin.Invoke(package, false, oldPackagePath, openProject);
}
try
{
PerformInstallLocal(package, openProject.DirectoryPath, _namespace);
}
catch (Exception ex)
{
Logger.WriteErrorLog(InstallerMessages.Error.INSTALL_PACK_FAILED, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
if (procEvents)
{
CleanupTempInstallDir(_namespace, false);
}
throw;
}
string packManStorePath = openProject.DirectoryPath + "\\" + Vars.PACKAGE_MANAGER_DIRECTORY;
if (!Directory.Exists(packManStorePath) && Helper.CreateFolderSafely(packManStorePath, _namespace, out outEx, LoggerMessages.GeneralError.CREATE_REQUIRED_DIR_FAILED_ARG) == CreateFolderResult.UserCancelled)
{
throw outEx;
}
InstalledPackage newInstall = null;
try
{
newInstall = CreateLocalInstalledFile(package, Path.GetDirectoryName(packagePath), packManStorePath, _namespace, out outLog);
openProject.InstalledPackages.AddSafely(newInstall);
}
catch
{
if (procEvents)
{
CleanupTempInstallDir(_namespace, false);
}
throw;
}
if (outLog != null)
{
log.Logs.AddRange(outLog.Logs);
}
if (!alreadyCopiedToTemp)
{
CleanupTempInstallDir(_namespace, false);
}
if (procEvents && OnPackageInstalled != null)
{
OnPackageInstalled.Invoke(package, false, oldPackagePath, openProject);
}
Logger.WriteInformationLog(InstallerMessages.Information.PACKAGE_INSTALL_DONE_L, _namespace);
return(newInstall);
}
public static InstalledPackage UpdateLocalPackage(string pathToInstaller, ProjectPackMan openProject, bool packageAlreadyCopiedToTemp, string _namespace, out LogDataList log, bool skipInstallFileExistenceCheck = false)
{
log = new LogDataList();
if (openProject == null)
{
try
{
throw new NullProjectException(ExceptionMessages.General.OPEN_PROJ_ARG_NULL);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Updater.Error.NO_OPEN_PROJ, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
if (string.IsNullOrWhiteSpace(openProject.DirectoryPath))
{
try
{
throw new InvalidPathException(ExceptionMessages.General.OPEN_PROJ_DIR_PATH_ARG_NULL, openProject.DirectoryPath);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Updater.Error.INVALID_OPEN_PROJ_DIR, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
string origPath = pathToInstaller;
Logger.WriteInformationLog(LoggerMessages.PackageManagement.Updater.Information.UpdatePackageStart(openProject.DirectoryPath, pathToInstaller), _namespace);
LogDataList outLog = null;
try
{
if (!packageAlreadyCopiedToTemp)
{
pathToInstaller = Installer.InitPackageInstaller(pathToInstaller, false, _namespace, out outLog);
}
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Updater.Error.UNABLE_EXTRACT_LOCAL + pathToInstaller + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
RMPackage package = null;
try
{
package = new RMPackage(pathToInstaller, _namespace, out outLog);
}
catch (Exception ex)
{
log.AppendLogs(outLog);
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Updater.Error.UNABLE_PARSE_XML_LOCAL + pathToInstaller + ".", _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
log.AppendLogs(outLog);
if (openProject.InstalledPackages == null)
{
try
{
throw new PackageNotFoundException(false, ExceptionMessages.General.PROJ_NO_PACKAGES);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Updater.Error.OPEN_PROJ_NOT_ABLE_FIND_PACK, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
InstalledPackage packageInstalled = openProject.InstalledPackages.FindByUID(package.UniqueID);
if (packageInstalled == null)
{
try
{
throw new PackageNotFoundException(false, ExceptionMessages.General.PackWIDNotFound(package.UniqueID));
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Updater.Error.OPEN_PROJ_NOT_ABLE_FIND_PACK, _namespace, ex, BasicDebugLogger.DebugErrorType.Error);
throw;
}
}
if (OnPackageUpdateBegin != null)
{
OnPackageUpdateBegin.Invoke(packageInstalled, package, false, origPath, openProject);
}
try
{
Uninstaller.UninstallLocalPackage(openProject, package.UniqueID, _namespace, out outLog, procEvents: false);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Updater.Error.FAILED_UNINSTALL, _namespace, ex, BasicDebugLogger.DebugErrorType.CriticalError);
throw;
}
log.AppendLogs(outLog);
InstalledPackage newlyInstalledPackage = null;
try
{
newlyInstalledPackage = Installer.InstallLocalPackage(pathToInstaller, openProject, _namespace, out outLog, true, true, false, skipInstallFileExistenceCheck);
}
catch (Exception ex)
{
Logger.WriteErrorLog(LoggerMessages.PackageManagement.Updater.Error.FAILED_INSTALL, _namespace, ex, BasicDebugLogger.DebugErrorType.CriticalError);
throw;
}
log.AppendLogs(outLog);
if (OnPackageUpdateDone != null)
{
OnPackageUpdateDone.Invoke(newlyInstalledPackage, newlyInstalledPackage.Package, false, origPath, openProject);
}
Logger.WriteInformationLog(LoggerMessages.PackageManagement.Updater.Information.UpdatePackageDone(origPath), _namespace);
return(newlyInstalledPackage);
}
public static void CloseProject()
{
OpenedProject = null;
}
public static void OpenProject(string pathToProjFile, string _namespace, out LogDataList log)
{
OpenedProject = new ProjectPackMan(Path.GetDirectoryName(pathToProjFile), _namespace, out log);
}
